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

camel/configs/base_config.py

@@ -39,13 +39,13 @@ class BaseConfig(ABC, BaseModel):
     @classmethod
     def fields_type_checking(cls, tools):
         if tools is not None:
-            from camel.toolkits import FunctionTool
+            from camel.toolkits import OpenAIFunction
 
             for tool in tools:
-                if not isinstance(tool, FunctionTool):
+                if not isinstance(tool, OpenAIFunction):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `FunctionTool`."
+                        "be an instance of `OpenAIFunction`."
                     )
         return tools
 
@@ -54,14 +54,14 @@ class BaseConfig(ABC, BaseModel):
 
         tools_schema = None
         if self.tools:
-            from camel.toolkits import FunctionTool
+            from camel.toolkits import OpenAIFunction
 
             tools_schema = []
             for tool in self.tools:
-                if not isinstance(tool, FunctionTool):
+                if not isinstance(tool, OpenAIFunction):
                     raise ValueError(
                         f"The tool {tool} should "
-                        "be an instance of `FunctionTool`."
+                        "be an instance of `OpenAIFunction`."
                     )
                 tools_schema.append(tool.get_openai_tool_schema())
         config_dict["tools"] = tools_schema

camel/configs/groq_config.py

@@ -15,8 +15,9 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
+
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class GroqConfig(BaseConfig):
@@ -72,7 +73,7 @@ class GroqConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[FunctionTool], optional): A list of tools the model may
+        tools (list[OpenAIFunction], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/ollama_config.py

@@ -15,8 +15,9 @@ from __future__ import annotations
 
 from typing import Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
+
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class OllamaConfig(BaseConfig):

camel/configs/openai_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class ChatGPTConfig(BaseConfig):
@@ -81,7 +81,7 @@ class ChatGPTConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[FunctionTool], optional): A list of tools the model may
+        tools (list[OpenAIFunction], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.
@@ -112,3 +112,24 @@ class ChatGPTConfig(BaseConfig):
 
 
 OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}
+
+
+class OpenSourceConfig(BaseConfig):
+    r"""Defines parameters for setting up open-source models and includes
+    parameters to be passed to chat completion function of OpenAI API.
+
+    Args:
+        model_path (str): The path to a local folder containing the model
+            files or the model card in HuggingFace hub.
+        server_url (str): The URL to the server running the model inference
+            which will be used as the API base of OpenAI API.
+        api_params (ChatGPTConfig): An instance of :obj:ChatGPTConfig to
+            contain the arguments to be passed to OpenAI API.
+    """
+
+    # Maybe the param needs to be renamed.
+    # Warning: Field "model_path" has conflict with protected namespace
+    # "model_".
+    model_path: str
+    server_url: str
+    api_params: ChatGPTConfig = Field(default_factory=ChatGPTConfig)

camel/configs/samba_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Any, Dict, Optional, Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class SambaFastAPIConfig(BaseConfig):
@@ -172,7 +172,7 @@ class SambaCloudAPIConfig(BaseConfig):
         user (str, optional): A unique identifier representing your end-user,
             which can help OpenAI to monitor and detect abuse.
             (default: :obj:`""`)
-        tools (list[FunctionTool], optional): A list of tools the model may
+        tools (list[OpenAIFunction], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/configs/togetherai_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Any, Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class TogetherAIConfig(BaseConfig):

camel/configs/vllm_config.py

@@ -15,10 +15,10 @@ from __future__ import annotations
 
 from typing import Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
 from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 # flake8: noqa: E501

camel/configs/zhipuai_config.py

@@ -15,8 +15,9 @@ from __future__ import annotations
 
 from typing import Optional, Sequence, Union
 
+from openai._types import NOT_GIVEN, NotGiven
+
 from camel.configs.base_config import BaseConfig
-from camel.types import NOT_GIVEN, NotGiven
 
 
 class ZhipuAIConfig(BaseConfig):
@@ -44,7 +45,7 @@ class ZhipuAIConfig(BaseConfig):
             in the chat completion. The total length of input tokens and
             generated tokens is limited by the model's context length.
             (default: :obj:`None`)
-        tools (list[FunctionTool], optional): A list of tools the model may
+        tools (list[OpenAIFunction], optional): A list of tools the model may
             call. Currently, only functions are supported as a tool. Use this
             to provide a list of functions the model may generate JSON inputs
             for. A max of 128 functions are supported.

camel/embeddings/openai_embedding.py

@@ -16,10 +16,10 @@ from __future__ import annotations
 import os
 from typing import Any
 
-from openai import OpenAI
+from openai import NOT_GIVEN, NotGiven, OpenAI
 
 from camel.embeddings.base import BaseEmbedding
-from camel.types import NOT_GIVEN, EmbeddingModelType, NotGiven
+from camel.types import EmbeddingModelType
 from camel.utils import api_keys_required
 
 

camel/loaders/__init__.py

@@ -13,7 +13,6 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base_io import File
-from .chunkr_reader import ChunkrReader
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
 from .unstructured_io import UnstructuredIO
@@ -23,5 +22,4 @@ __all__ = [
     'UnstructuredIO',
     'JinaURLReader',
     'Firecrawl',
-    'ChunkrReader',
 ]

camel/loaders/firecrawl_reader.py

@@ -155,12 +155,12 @@ class Firecrawl:
         except Exception as e:
             raise RuntimeError(f"Failed to scrape the URL: {e}")
 
-    def structured_scrape(self, url: str, response_format: BaseModel) -> Dict:
+    def structured_scrape(self, url: str, output_schema: BaseModel) -> Dict:
         r"""Use LLM to extract structured data from given URL.
 
         Args:
             url (str): The URL to read.
-            response_format (BaseModel): A pydantic model
+            output_schema (BaseModel): A pydantic model
                 that includes value types and field descriptions used to
                 generate a structured response by LLM. This schema helps
                 in defining the expected output format.
@@ -176,7 +176,7 @@ class Firecrawl:
                 url,
                 {
                     'formats': ['extract'],
-                    'extract': {'schema': response_format.model_json_schema()},
+                    'extract': {'schema': output_schema.model_json_schema()},
                 },
             )
             return data.get("extract", {})

camel/loaders/unstructured_io.py

@@ -13,9 +13,8 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import uuid
 import warnings
+from io import IOBase
 from typing import (
-    IO,
-    TYPE_CHECKING,
     Any,
     Dict,
     List,
@@ -25,8 +24,7 @@ from typing import (
     Union,
 )
 
-if TYPE_CHECKING:
-    from unstructured.documents.elements import Element
+from unstructured.documents.elements import Element
 
 
 class UnstructuredIO:
@@ -42,34 +40,33 @@ class UnstructuredIO:
     @staticmethod
     def create_element_from_text(
         text: str,
-        element_id: Optional[str] = None,
+        element_id: Optional[Union[str, uuid.UUID]] = None,
         embeddings: Optional[List[float]] = None,
         filename: Optional[str] = None,
         file_directory: Optional[str] = None,
         last_modified: Optional[str] = None,
         filetype: Optional[str] = None,
-        parent_id: Optional[str] = None,
-    ) -> "Element":
+        parent_id: Optional[Union[str, uuid.UUID]] = None,
+    ) -> Element:
         r"""Creates a Text element from a given text input, with optional
         metadata and embeddings.
 
         Args:
             text (str): The text content for the element.
-            element_id (Optional[str], optional): Unique identifier for the
-                element. (default: :obj:`None`)
-            embeddings (List[float], optional): A list of float
-                numbers representing the text embeddings.
-                (default: :obj:`None`)
+            element_id (Optional[Union[str, uuid.UUID]], optional): Unique
+                identifier for the element. Defaults to `None`.
+            embeddings (Optional[List[float]], optional): A list of float
+                numbers representing the text embeddings. Defaults to `None`.
             filename (Optional[str], optional): The name of the file the
-                element is associated with. (default: :obj:`None`)
+                element is associated with. Defaults to `None`.
             file_directory (Optional[str], optional): The directory path where
-                the file is located. (default: :obj:`None`)
+                the file is located. Defaults to `None`.
             last_modified (Optional[str], optional): The last modified date of
-                the file. (default: :obj:`None`)
-            filetype (Optional[str], optional): The type of the file.
-                (default: :obj:`None`)
-            parent_id (Optional[str], optional): The identifier of the parent
-                element. (default: :obj:`None`)
+                the file. Defaults to `None`.
+            filetype (Optional[str], optional): The type of the file. Defaults
+                to `None`.
+            parent_id (Optional[Union[str, uuid.UUID]], optional): The
+                identifier of the parent element. Defaults to `None`.
 
         Returns:
             Element: An instance of Text with the provided content and
@@ -87,7 +84,7 @@ class UnstructuredIO:
 
         return Text(
             text=text,
-            element_id=element_id or str(uuid.uuid4()),
+            element_id=element_id or uuid.uuid4(),
             metadata=metadata,
             embeddings=embeddings,
         )
@@ -96,7 +93,7 @@ class UnstructuredIO:
     def parse_file_or_url(
         input_path: str,
         **kwargs: Any,
-    ) -> Union[List["Element"], None]:
+    ) -> Union[List[Element], None]:
         r"""Loads a file or a URL and parses its contents into elements.
 
         Args:
@@ -122,23 +119,25 @@ class UnstructuredIO:
         import os
         from urllib.parse import urlparse
 
-        from unstructured.partition.auto import partition
-
         # Check if the input is a URL
         parsed_url = urlparse(input_path)
         is_url = all([parsed_url.scheme, parsed_url.netloc])
 
-        # Handling URL
         if is_url:
+            # Handling URL
+            from unstructured.partition.html import partition_html
+
             try:
-                elements = partition(url=input_path, **kwargs)
+                elements = partition_html(url=input_path, **kwargs)
                 return elements
             except Exception:
                 warnings.warn(f"Failed to parse the URL: {input_path}")
                 return None
 
-        # Handling file
         else:
+            # Handling file
+            from unstructured.partition.auto import partition
+
             # Check if the file exists
             if not os.path.exists(input_path):
                 raise FileNotFoundError(
@@ -155,13 +154,11 @@ class UnstructuredIO:
                 return None
 
     @staticmethod
-    def parse_bytes(
-        file: IO[bytes], **kwargs: Any
-    ) -> Union[List["Element"], None]:
+    def parse_bytes(file: IOBase, **kwargs: Any) -> Union[List[Element], None]:
         r"""Parses a bytes stream and converts its contents into elements.
 
         Args:
-            file (IO[bytes]): The file in bytes format to be parsed.
+            file (IOBase): The file in bytes format to be parsed.
             **kwargs: Extra kwargs passed to the partition function.
 
         Returns:
@@ -184,6 +181,8 @@ class UnstructuredIO:
             elements = partition(file=file, **kwargs)
             return elements
         except Exception as e:
+            import warnings
+
             warnings.warn(f"Failed to partition the file stream: {e}")
             return None
 
@@ -197,7 +196,7 @@ class UnstructuredIO:
 
         This function applies multiple text cleaning utilities by calling the
         `unstructured` library's cleaning bricks for operations like
-        replacing Unicode quotes, removing extra whitespace, dashes, non-ascii
+        replacing unicode quotes, removing extra whitespace, dashes, non-ascii
         characters, and more.
 
         If no cleaning options are provided, a default set of cleaning
@@ -284,8 +283,7 @@ class UnstructuredIO:
                 )
             else:
                 raise ValueError(
-                    f"'{func_name}' is not a valid function in "
-                    "`Unstructured IO`."
+                    f"'{func_name}' is not a valid function in `unstructured`."
                 )
 
         return cleaned_text
@@ -442,8 +440,8 @@ class UnstructuredIO:
 
     @staticmethod
     def chunk_elements(
-        elements: List["Element"], chunk_type: str, **kwargs
-    ) -> List["Element"]:
+        elements: List[Any], chunk_type: str, **kwargs
+    ) -> List[Element]:
         r"""Chunks elements by titles.
 
         Args:

camel/messages/__init__.py

@@ -32,7 +32,6 @@ __all__ = [
     'OpenAISystemMessage',
     'OpenAIAssistantMessage',
     'OpenAIUserMessage',
-    'OpenAIFunctionMessage',
     'OpenAIMessage',
     'BaseMessage',
     'FunctionCallingMessage',

camel/models/__init__.py

@@ -21,8 +21,9 @@ from .mistral_model import MistralModel
 from .model_factory import ModelFactory
 from .nemotron_model import NemotronModel
 from .ollama_model import OllamaModel
+from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
-from .openai_compatible_model import OpenAICompatibleModel
+from .openai_compatibility_model import OpenAICompatibilityModel
 from .openai_model import OpenAIModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
@@ -40,6 +41,7 @@ __all__ = [
     'GroqModel',
     'StubModel',
     'ZhipuAIModel',
+    'OpenSourceModel',
     'ModelFactory',
     'LiteLLMModel',
     'OpenAIAudioModels',
@@ -47,7 +49,7 @@ __all__ = [
     'OllamaModel',
     'VLLMModel',
     'GeminiModel',
-    'OpenAICompatibleModel',
+    'OpenAICompatibilityModel',
     'RekaModel',
     'SambaModel',
     'TogetherAIModel',

camel/models/anthropic_model.py

@@ -12,9 +12,11 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
-from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
+from anthropic import NOT_GIVEN, Anthropic
+
+from camel.configs import ANTHROPIC_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
@@ -22,47 +24,40 @@ from camel.utils import (
     AnthropicTokenCounter,
     BaseTokenCounter,
     api_keys_required,
-    dependencies_required,
 )
 
 
 class AnthropicModel(BaseModelBackend):
-    r"""Anthropic API in a unified BaseModelBackend interface.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of CLAUDE_* series.
-        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into Anthropic.messages.create().  If
-            :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
-            (default::obj:`None`)
-        api_key (Optional[str], optional): The API key for authenticating with
-            the Anthropic service. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the Anthropic service.
-            (default: :obj:`None`)
-        token_counter (Optional[BaseTokenCounter], optional): Token counter to
-            use for the model. If not provided, :obj:`AnthropicTokenCounter`
-            will be used. (default: :obj:`None`)
-    """
-
-    @dependencies_required('anthropic')
+    r"""Anthropic API in a unified BaseModelBackend interface."""
+
     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,
     ) -> None:
-        from anthropic import Anthropic
+        r"""Constructor for Anthropic backend.
 
-        if model_config_dict is None:
-            model_config_dict = AnthropicConfig().as_dict()
-        api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of CLAUDE_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into Anthropic.messages.create().
+            api_key (Optional[str]): The API key for authenticating with the
+                Anthropic service. (default: :obj:`None`)
+            url (Optional[str]): The url to the Anthropic service. (default:
+                :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `AnthropicTokenCounter` will
+                be used.
+        """
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
+        self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        self._url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
         self.client = Anthropic(api_key=self._api_key, base_url=self._url)
 
     def _convert_response_from_anthropic_to_openai(self, response):
@@ -94,7 +89,7 @@ class AnthropicModel(BaseModelBackend):
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = AnthropicTokenCounter()
+            self._token_counter = AnthropicTokenCounter(self.model_type)
         return self._token_counter
 
     def count_tokens_from_prompt(self, prompt: str) -> int:
@@ -122,14 +117,13 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
 
         if messages[0]["role"] == "system":
             sys_msg = str(messages.pop(0)["content"])
         else:
             sys_msg = NOT_GIVEN  # type: ignore[assignment]
         response = self.client.messages.create(
-            model=self.model_type,
+            model=self.model_type.value,
             system=sys_msg,
             messages=messages,  # type: ignore[arg-type]
             **self.model_config_dict,

camel/models/azure_openai_model.py

@@ -16,65 +16,60 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import AzureOpenAI, Stream
 
-from camel.configs import OPENAI_API_PARAMS, ChatGPTConfig
+from camel.configs import OPENAI_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.models.base_model import BaseModelBackend
-from camel.types import (
-    ChatCompletion,
-    ChatCompletionChunk,
-    ModelType,
-)
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
 from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
 
 
 class AzureOpenAIModel(BaseModelBackend):
     r"""Azure OpenAI API in a unified BaseModelBackend interface.
-
-    Args:
-        model_type (Union[ModelType, str]): Model for which a backend is
-            created, one of GPT_* series.
-        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into:obj:`openai.ChatCompletion.create()`. If
-            :obj:`None`, :obj:`ChatGPTConfig().as_dict()` will be used.
-            (default: :obj:`None`)
-        api_key (Optional[str], optional): The API key for authenticating with
-            the OpenAI service. (default: :obj:`None`)
-        url (Optional[str], optional): The url to the OpenAI service.
-            (default: :obj:`None`)
-        api_version (Optional[str], optional): The api version for the model.
-            (default: :obj:`None`)
-        azure_deployment_name (Optional[str], optional): The deployment name
-            you chose when you deployed an azure model. (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`)
-
-    References:
-        https://learn.microsoft.com/en-us/azure/ai-services/openai/
+    Doc: https://learn.microsoft.com/en-us/azure/ai-services/openai/
     """
 
     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,
         api_version: Optional[str] = None,
         azure_deployment_name: Optional[str] = None,
     ) -> None:
-        if model_config_dict is None:
-            model_config_dict = ChatGPTConfig().as_dict()
-        api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
-        url = url or os.environ.get("AZURE_OPENAI_BASE_URL")
-        super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
-        )
+        r"""Constructor for OpenAI backend.
 
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of GPT_* series.
+            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
+                OpenAI service. (default: :obj:`None`)
+            url (Optional[str]): The url to the OpenAI service. (default:
+                :obj:`None`)
+            api_version (Optional[str]): The api version for the model.
+            azure_deployment_name (Optional[str]): The deployment name you
+                chose when you deployed an azure model. (default: :obj:`None`)
+        """
+        super().__init__(model_type, model_config_dict, api_key, url)
+        self._url = url or os.environ.get("AZURE_OPENAI_ENDPOINT")
+        self._api_key = api_key or os.environ.get("AZURE_OPENAI_API_KEY")
         self.api_version = api_version or os.environ.get("AZURE_API_VERSION")
         self.azure_deployment_name = azure_deployment_name or os.environ.get(
             "AZURE_DEPLOYMENT_NAME"
         )
+
+        if self._url is None:
+            raise ValueError(
+                "Must provide either the `url` argument "
+                "or `AZURE_OPENAI_ENDPOINT` environment variable."
+            )
+        if self._api_key is None:
+            raise ValueError(
+                "Must provide either the `api_key` argument "
+                "or `AZURE_OPENAI_API_KEY` environment variable."
+            )
         if self.api_version is None:
             raise ValueError(
                 "Must provide either the `api_version` argument "
@@ -85,6 +80,7 @@ class AzureOpenAIModel(BaseModelBackend):
                 "Must provide either the `azure_deployment_name` argument "
                 "or `AZURE_DEPLOYMENT_NAME` environment variable."
             )
+        self.model = str(self.azure_deployment_name)
 
         self._client = AzureOpenAI(
             azure_endpoint=str(self._url),
@@ -94,6 +90,7 @@ class AzureOpenAIModel(BaseModelBackend):
             timeout=60,
             max_retries=3,
         )
+        self._token_counter: Optional[BaseTokenCounter] = None
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -125,7 +122,7 @@ class AzureOpenAIModel(BaseModelBackend):
         """
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            model=self.model,
             **self.model_config_dict,
         )
         return response