camel-ai 0.1.6.6__py3-none-any.whl → 0.1.6.8__py3-none-any.whl

camel/models/reka_model.py

@@ -0,0 +1,232 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.configs import REKA_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+if TYPE_CHECKING:
+    from reka.types import ChatMessage, ChatResponse
+
+try:
+    import os
+
+    if os.getenv("AGENTOPS_API_KEY") is not None:
+        from agentops import LLMEvent, record
+    else:
+        raise ImportError
+except (ImportError, AttributeError):
+    LLMEvent = None
+
+
+class RekaModel(BaseModelBackend):
+    r"""Reka API in a unified BaseModelBackend interface."""
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        r"""Constructor for Reka backend.
+
+        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.
+        """
+        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'
+    ) -> ChatCompletion:
+        r"""Converts a Reka `ChatResponse` to an OpenAI-style `ChatCompletion`
+        response.
+
+        Args:
+            response (ChatResponse): The response object from the Reka API.
+
+        Returns:
+            ChatCompletion: An OpenAI-compatible chat completion response.
+        """
+        openai_response = ChatCompletion.construct(
+            id=response.id,
+            choices=[
+                dict(
+                    message={
+                        "role": response.responses[0].message.role,
+                        "content": response.responses[0].message.content,
+                    },
+                    finish_reason=response.responses[0].finish_reason
+                    if response.responses[0].finish_reason
+                    else None,
+                )
+            ],
+            created=None,
+            model=response.model,
+            object="chat.completion",
+            usage=response.usage,
+        )
+
+        return openai_response
+
+    def _convert_openai_to_reka_messages(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> List["ChatMessage"]:
+        r"""Converts OpenAI API messages to Reka API messages.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages in OpenAI
+                format.
+
+        Returns:
+            List[ChatMessage]: A list of messages converted to Reka's format.
+        """
+        from reka.types import ChatMessage
+
+        reka_messages = []
+        for msg in messages:
+            role = msg.get("role")
+            content = str(msg.get("content"))
+
+            if role == "user":
+                reka_messages.append(ChatMessage(role="user", content=content))
+            elif role == "assistant":
+                reka_messages.append(
+                    ChatMessage(role="assistant", content=content)
+                )
+            elif role == "system":
+                reka_messages.append(ChatMessage(role="user", content=content))
+
+                # Add one more assistant msg since Reka requires conversation
+                # history must alternate between 'user' and 'assistant',
+                # starting and ending with 'user'.
+                reka_messages.append(
+                    ChatMessage(
+                        role="assistant",
+                        content="",
+                    )
+                )
+            else:
+                raise ValueError(f"Unsupported message role: {role}")
+
+        return reka_messages
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        # NOTE: Temporarily using `OpenAITokenCounter`
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(
+                model=ModelType.GPT_4O_MINI
+            )
+        return self._token_counter
+
+    @api_keys_required("REKA_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of Mistral chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            ChatCompletion.
+        """
+        reka_messages = self._convert_openai_to_reka_messages(messages)
+
+        response = self._client.chat.create(
+            messages=reka_messages,
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+
+        openai_response = self._convert_reka_to_openai_response(response)
+
+        # Add AgentOps LLM Event tracking
+        if LLMEvent:
+            llm_event = LLMEvent(
+                thread_id=openai_response.id,
+                prompt=" ".join(
+                    [message.get("content") for message in messages]  # type: ignore[misc]
+                ),
+                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,
+            )
+            record(llm_event)
+
+        return openai_response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Reka API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Reka API.
+        """
+        for param in self.model_config_dict:
+            if param not in REKA_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Reka model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/samba_model.py

@@ -0,0 +1,291 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import SAMBA_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class SambaModel:
+    r"""SambaNova service interface."""
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        r"""Constructor for SambaNova backend.
+
+        Args:
+            model_type (ModelType): Model for which a SambaNova backend is
+                created.
+            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. (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")
+        self._token_counter = token_counter
+        self.model_config_dict = model_config_dict
+        self.check_model_config()
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to SambaNova API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to SambaNova API.
+        """
+        for param in self.model_config_dict:
+            if param not in SAMBA_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into SambaNova model backend."
+                )
+
+    @api_keys_required("SAMBA_API_KEY")
+    def run(  # type: ignore[misc]
+        self, messages: List[OpenAIMessage]
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs SambaNova's FastAPI service.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+
+        if self.model_config_dict.get("stream") is True:
+            return self._run_streaming(messages)
+        else:
+            return self._run_non_streaming(messages)
+
+    def _run_streaming(  # type: ignore[misc]
+        self, messages: List[OpenAIMessage]
+    ) -> Stream[ChatCompletionChunk]:
+        r"""Handles streaming inference with SambaNova FastAPI.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                chat history in OpenAI API format.
+
+        Returns:
+            Stream[ChatCompletionChunk]: A generator yielding
+                `ChatCompletionChunk` objects as they are received from the
+                API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+        """
+
+        import httpx
+
+        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.value,
+            "stream": True,
+            "stream_options": self.model_config_dict.get("stream_options"),
+        }
+
+        try:
+            with httpx.stream(
+                "POST",
+                self._url or "https://fast-api.snova.ai/v1/chat/completions",
+                headers=headers,
+                json=data,
+            ) as api_response:
+                stream = Stream[ChatCompletionChunk](
+                    cast_to=ChatCompletionChunk,
+                    response=api_response,
+                    client=OpenAI(),
+                )
+                for chunk in stream:
+                    yield chunk
+        except httpx.HTTPError as e:
+            raise RuntimeError(f"HTTP request failed: {e!s}")
+
+    def _run_non_streaming(
+        self, messages: List[OpenAIMessage]
+    ) -> ChatCompletion:
+        r"""Handles non-streaming inference with SambaNova FastAPI.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                message in OpenAI API format.
+
+        Returns:
+            ChatCompletion: A `ChatCompletion` object containing the complete
+                response from the API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+            ValueError: If the JSON response cannot be decoded or is missing
+                expected data.
+        """
+
+        import json
+
+        import httpx
+
+        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.value,
+            "stream": True,
+            "stream_options": self.model_config_dict.get("stream_options"),
+        }
+
+        try:
+            with httpx.stream(
+                "POST",
+                self._url or "https://fast-api.snova.ai/v1/chat/completions",
+                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._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}")
+
+    def _to_openai_response(
+        self, samba_response: List[Dict[str, Any]]
+    ) -> ChatCompletion:
+        r"""Converts SambaNova response chunks into an OpenAI-compatible
+        response.
+
+        Args:
+            samba_response (List[Dict[str, Any]]): A list of dictionaries
+                representing partial responses from the SambaNova API.
+
+        Returns:
+            ChatCompletion: A `ChatCompletion` object constructed from the
+                aggregated response data.
+
+        Raises:
+            ValueError: If the response data is invalid or incomplete.
+        """
+        # 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
+
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the maximum token limit for a given model.
+
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        return (
+            self.model_config_dict.get("max_tokens")
+            or self.model_type.token_limit
+        )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/togetherai_model.py

@@ -0,0 +1,148 @@
+# =========== Copyright 2023 @ 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 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import TOGETHERAI_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class TogetherAIModel:
+    r"""Constructor for Together AI backend with OpenAI compatibility.
+    TODO: Add function calling support
+    """
+
+    def __init__(
+        self,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
+        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")
+
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url or "https://api.together.xyz/v1",
+        )
+
+    @api_keys_required("TOGETHER_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        # Use OpenAI cilent as interface call Together AI
+        # Reference: https://docs.together.ai/docs/openai-api-compatibility
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to TogetherAI API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to TogetherAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in TOGETHERAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into TogetherAI model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            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