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

camel/models/samba_model.py

@@ -22,11 +22,10 @@ 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,
@@ -39,59 +38,48 @@ from camel.utils import (
     api_keys_required,
 )
 
-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.
-    """
+
+class SambaModel:
+    r"""SambaNova service interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        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(
+        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(
             "SAMBA_API_BASE_URL",
-            "https://api.sambanova.ai/v1",
-        )
-        super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            "https://fast-api.snova.ai/v1/chat/completions",
         )
+        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(
@@ -121,7 +109,14 @@ class SambaModel(BaseModelBackend):
             ValueError: If the model configuration dictionary contains any
                 unexpected arguments to SambaNova API.
         """
-        if self._url == "https://sambaverse.sambanova.ai/api/predict":
+        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":
             for param in self.model_config_dict:
                 if param not in SAMBA_VERSE_API_PARAMS:
                     raise ValueError(
@@ -164,7 +159,7 @@ class SambaModel(BaseModelBackend):
         else:
             return self._run_non_streaming(messages)
 
-    def _run_streaming(
+    def _run_streaming(  # type: ignore[misc]
         self, messages: List[OpenAIMessage]
     ) -> Stream[ChatCompletionChunk]:
         r"""Handles streaming inference with SambaNova's API.
@@ -180,30 +175,48 @@ class SambaModel(BaseModelBackend):
 
         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
-        if self._url == "https://api.sambanova.ai/v1":
+        elif 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":
@@ -211,7 +224,6 @@ class SambaModel(BaseModelBackend):
                 "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]
@@ -231,28 +243,51 @@ class SambaModel(BaseModelBackend):
             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
-        if self._url == "https://api.sambanova.ai/v1":
+        elif 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
@@ -335,6 +370,56 @@ class SambaModel(BaseModelBackend):
             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:
@@ -384,6 +469,16 @@ class SambaModel(BaseModelBackend):
 
         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: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,

camel/models/togetherai_model.py

@@ -17,14 +17,9 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import TOGETHERAI_API_PARAMS, TogetherAIConfig
+from camel.configs import TOGETHERAI_API_PARAMS
 from camel.messages import OpenAIMessage
-from camel.models import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -32,50 +27,45 @@ from camel.utils import (
 )
 
 
-class TogetherAIModel(BaseModelBackend):
+class TogetherAIModel:
     r"""Constructor for Together AI backend with OpenAI compatibility.
-
-    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.
+    TODO: Add function calling support
     """
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        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
-        )
+        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")
 
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
             api_key=self._api_key,
-            base_url=self._url,
+            base_url=self._url or "https://api.together.xyz/v1",
         )
 
     @api_keys_required("TOGETHER_API_KEY")
@@ -140,3 +130,19 @@ class TogetherAIModel(BaseModelBackend):
             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,66 +17,58 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import VLLM_API_PARAMS, VLLMConfig
+from camel.configs import VLLM_API_PARAMS
 from camel.messages import OpenAIMessage
-from camel.models import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
 
 # flake8: noqa: E501
-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
-    """
+class VLLMModel:
+    r"""vLLM service interface."""
 
     def __init__(
         self,
-        model_type: Union[ModelType, str],
-        model_config_dict: Optional[Dict[str, Any]] = None,
-        api_key: Optional[str] = None,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
         url: Optional[str] = None,
+        api_key: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        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
+        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 not self._url:
+        if not url and not os.environ.get("VLLM_BASE_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."""
@@ -86,9 +78,8 @@ class VLLMModel(BaseModelBackend):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
-            self._url = "http://localhost:8000/v1"
             print(
-                f"vllm server started on {self._url} "
+                f"vllm server started on http://localhost:8000/v1 "
                 f"for {self.model_type} model."
             )
         except Exception as e:
@@ -144,6 +135,22 @@ class VLLMModel(BaseModelBackend):
         )
         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