camel-ai 0.1.5.6__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/agents/role_assignment_agent.py

@@ -20,14 +20,26 @@ from camel.models import BaseModelBackend
 from camel.prompts import TextPrompt
 from camel.types import RoleType
 
+# AgentOps decorator setting
+try:
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
+
+
+@track_agent(name="RoleAssignmentAgent")
 class RoleAssignmentAgent(ChatAgent):
     r"""An agent that generates role names based on the task prompt.
 
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
 
     Attributes:
         role_assignment_prompt (TextPrompt): A prompt for the agent to generate

camel/agents/search_agent.py

@@ -20,16 +20,27 @@ from camel.prompts import TextPrompt
 from camel.types import RoleType
 from camel.utils import create_chunks
 
+# AgentOps decorator setting
+try:
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
+
+
+@track_agent(name="SearchAgent")
 class SearchAgent(ChatAgent):
     r"""An agent that summarizes text based on a query and evaluates the
     relevance of an answer.
 
     Args:
-        model_type (ModelType, optional): The type of model to use for the
-            agent. (default: :obj:`ModelType.GPT_3_5_TURBO`)
-        model_config (Any, optional): The configuration for the model.
-            (default: :obj:`None`)
+        model (BaseModelBackend, optional): The model backend to use for
+            generating responses. (default: :obj:`OpenAIModel` with
+            `GPT_4O_MINI`)
     """
 
     def __init__(
@@ -76,7 +87,7 @@ class SearchAgent(ChatAgent):
             result = self.step(user_msg).msg.content
             results += result + "\n"
 
-        # Final summarise
+        # Final summarization
         final_prompt = TextPrompt(
             '''Here are some summarized texts which split from one text. Using
             the information to answer the question. If can't find the answer,

camel/agents/task_agent.py

@@ -20,7 +20,19 @@ from camel.prompts import PromptTemplateGenerator, TextPrompt
 from camel.types import RoleType, TaskType
 from camel.utils import get_task_list
 
+# AgentOps decorator setting
+try:
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
+
+
+@track_agent(name="TaskSpecifyAgent")
 class TaskSpecifyAgent(ChatAgent):
     r"""An agent that specifies a given task prompt by prompting the user to
     provide more details.
@@ -32,7 +44,7 @@ class TaskSpecifyAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         task_type (TaskType, optional): The type of task for which to generate
             a prompt. (default: :obj:`TaskType.AI_SOCIETY`)
         task_specify_prompt (Union[str, TextPrompt], optional): The prompt for
@@ -115,6 +127,7 @@ class TaskSpecifyAgent(ChatAgent):
         return TextPrompt(specified_task_msg.content)
 
 
+@track_agent(name="TaskPlannerAgent")
 class TaskPlannerAgent(ChatAgent):
     r"""An agent that helps divide a task into subtasks based on the input
     task prompt.
@@ -126,7 +139,7 @@ class TaskPlannerAgent(ChatAgent):
     Args:
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
     """
@@ -184,6 +197,7 @@ class TaskPlannerAgent(ChatAgent):
         return TextPrompt(sub_tasks_msg.content)
 
 
+@track_agent(name="TaskCreationAgent")
 class TaskCreationAgent(ChatAgent):
     r"""An agent that helps create new tasks based on the objective
     and last completed task. Compared to :obj:`TaskPlannerAgent`,
@@ -201,7 +215,7 @@ class TaskCreationAgent(ChatAgent):
             perform the task.
         model (BaseModelBackend, optional): The LLM backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
         message_window_size (int, optional): The maximum number of previous
@@ -233,7 +247,7 @@ The result must be a numbered list in the format:
     #. Third Task
 
 You can only give me up to {max_task_num} tasks at a time. \
-Each task shoud be concise, concrete and doable for a {role_name}.
+Each task should be concise, concrete and doable for a {role_name}.
 You should make task plan and not ask me questions.
 If you think no new tasks are needed right now, write "No tasks to add."
 Now start to give me new tasks one by one. No more than three tasks.
@@ -298,6 +312,7 @@ Be concrete.
         return get_task_list(sub_tasks_msg.content)
 
 
+@track_agent(name="TaskPrioritizationAgent")
 class TaskPrioritizationAgent(ChatAgent):
     r"""An agent that helps re-prioritize the task list and
     returns numbered prioritized list. Modified from
@@ -312,7 +327,7 @@ class TaskPrioritizationAgent(ChatAgent):
             perform the task.
         model (BaseModelBackend, optional): The LLM backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         output_language (str, optional): The language to be output by the
             agent. (default: :obj:`None`)
         message_window_size (int, optional): The maximum number of previous

camel/configs/__init__.py

@@ -13,17 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
-from .gemini_config import (
-    Gemini_API_PARAMS,
-    GeminiConfig,
-)
+from .gemini_config import Gemini_API_PARAMS, GeminiConfig
+from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
+from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
-from .openai_config import (
-    OPENAI_API_PARAMS,
-    ChatGPTConfig,
-    OpenSourceConfig,
-)
+from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
+from .vllm_config import VLLM_API_PARAMS, VLLMConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
 __all__ = [
@@ -32,6 +28,8 @@ __all__ = [
     'OPENAI_API_PARAMS',
     'AnthropicConfig',
     'ANTHROPIC_API_PARAMS',
+    'GROQ_API_PARAMS',
+    'GroqConfig',
     'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
@@ -41,4 +39,8 @@ __all__ = [
     'ZHIPUAI_API_PARAMS',
     'GeminiConfig',
     'Gemini_API_PARAMS',
+    'VLLMConfig',
+    'VLLM_API_PARAMS',
+    'MistralConfig',
+    'MISTRAL_API_PARAMS',
 ]

camel/configs/anthropic_config.py

@@ -13,14 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
+from typing import List, Union
 
 from anthropic import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class AnthropicConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     Anthropic API.
@@ -62,12 +61,12 @@ class AnthropicConfig(BaseConfig):
     """
 
     max_tokens: int = 256
-    stop_sequences: list[str] | NotGiven = NOT_GIVEN
+    stop_sequences: Union[List[str], NotGiven] = NOT_GIVEN
     temperature: float = 1
-    top_p: float | NotGiven = NOT_GIVEN
-    top_k: int | NotGiven = NOT_GIVEN
+    top_p: Union[float, NotGiven] = NOT_GIVEN
+    top_k: Union[int, NotGiven] = NOT_GIVEN
     metadata: NotGiven = NOT_GIVEN
     stream: bool = False
 
 
-ANTHROPIC_API_PARAMS = {param for param in asdict(AnthropicConfig()).keys()}
+ANTHROPIC_API_PARAMS = {param for param in AnthropicConfig.model_fields.keys()}

camel/configs/base_config.py

@@ -14,9 +14,55 @@
 from __future__ import annotations
 
 from abc import ABC
-from dataclasses import dataclass
+from typing import Any, List, Optional
 
+from pydantic import BaseModel, ConfigDict, field_validator
 
-@dataclass(frozen=True)
-class BaseConfig(ABC):  # noqa: B024
-    pass
+
+class BaseConfig(ABC, BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+        frozen=True,
+        # UserWarning: conflict with protected namespace "model_"
+        protected_namespaces=(),
+    )
+
+    tools: Optional[List[Any]] = None
+    """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.
+    """
+
+    @field_validator("tools", mode="before")
+    @classmethod
+    def fields_type_checking(cls, tools):
+        if tools is not None:
+            from camel.toolkits import OpenAIFunction
+
+            for tool in tools:
+                if not isinstance(tool, OpenAIFunction):
+                    raise ValueError(
+                        f"The tool {tool} should "
+                        "be an instance of `OpenAIFunction`."
+                    )
+        return tools
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = self.model_dump()
+
+        tools_schema = None
+        if self.tools:
+            from camel.toolkits import OpenAIFunction
+
+            tools_schema = []
+            for tool in self.tools:
+                if not isinstance(tool, OpenAIFunction):
+                    raise ValueError(
+                        f"The tool {tool} should "
+                        "be an instance of `OpenAIFunction`."
+                    )
+                tools_schema.append(tool.get_openai_tool_schema())
+        config_dict["tools"] = tools_schema
+        return config_dict

camel/configs/gemini_config.py

@@ -14,13 +14,13 @@
 
 
 from collections.abc import Iterable
-from dataclasses import asdict, dataclass
-from typing import Optional
+from typing import Any, Optional
+
+from pydantic import model_validator
 
 from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class GeminiConfig(BaseConfig):
     r"""A simple dataclass used to configure the generation parameters of
     `GenerativeModel.generate_content`.
@@ -72,14 +72,6 @@ class GeminiConfig(BaseConfig):
             Options for the request.
     """
 
-    from google.generativeai.protos import Schema
-    from google.generativeai.types.content_types import (
-        FunctionLibraryType,
-        ToolConfigType,
-    )
-    from google.generativeai.types.helper_types import RequestOptionsType
-    from google.generativeai.types.safety_types import SafetySettingOptions
-
     candidate_count: Optional[int] = None
     stop_sequences: Optional[Iterable[str]] = None
     max_output_tokens: Optional[int] = None
@@ -87,11 +79,71 @@ class GeminiConfig(BaseConfig):
     top_p: Optional[float] = None
     top_k: Optional[int] = None
     response_mime_type: Optional[str] = None
-    response_schema: Optional[Schema] = None
-    safety_settings: Optional[SafetySettingOptions] = None
-    tools: Optional[FunctionLibraryType] = None
-    tool_config: Optional[ToolConfigType] = None
-    request_options: Optional[RequestOptionsType] = None
+    response_schema: Optional[Any] = None
+    safety_settings: Optional[Any] = None
+    tools: Optional[Any] = None
+    tool_config: Optional[Any] = None
+    request_options: Optional[Any] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def fields_type_checking(cls, data: Any):
+        if isinstance(data, dict):
+            response_schema = data.get("response_schema")
+            safety_settings = data.get("safety_settings")
+            tools = data.get("tools")
+            tool_config = data.get("tool_config")
+            request_options = data.get("request_options")
+
+            if response_schema:
+                from google.generativeai.protos import Schema
+                from google.generativeai.types.content_types import (
+                    FunctionLibraryType,
+                    ToolConfigType,
+                )
+                from google.generativeai.types.helper_types import (
+                    RequestOptionsType,
+                )
+                from google.generativeai.types.safety_types import (
+                    SafetySettingOptions,
+                )
+        else:
+            return data
+
+        if response_schema and not isinstance(response_schema, Schema):
+            raise ValueError(
+                "The response_schema should be "
+                "an instance of `google.generativeai.protos.Schema`."
+            )
+
+        if safety_settings and not isinstance(
+            safety_settings, SafetySettingOptions
+        ):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.safety_types.SafetySettingOptions`."
+            )
+
+        if tools is not None:
+            for tool in tools:
+                if not isinstance(tool, FunctionLibraryType):
+                    raise ValueError(
+                        "The tool should be an instance of "
+                        "`google.generativeai.types.content_types.FunctionLibraryType`."
+                    )
+        if tool_config and not isinstance(tool_config, ToolConfigType):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.content_types.ToolConfigType`."
+            )
+        if request_options and not isinstance(
+            request_options, RequestOptionsType
+        ):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.helper_types.RequestOptionsType`."
+            )
+        return data
 
 
-Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}
+Gemini_API_PARAMS = {param for param in GeminiConfig().model_fields.keys()}

camel/configs/groq_config.py

@@ -0,0 +1,105 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Optional, Sequence, Union
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+
+class GroqConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility.
+
+    Reference: https://console.groq.com/docs/openai
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+        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.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: Union[dict, NotGiven] = NOT_GIVEN
+    frequency_penalty: float = 0.0
+    user: str = ""
+    tool_choice: Optional[Union[dict[str, str], str]] = "none"
+
+
+GROQ_API_PARAMS = {param for param in GroqConfig.model_fields.keys()}

camel/configs/litellm_config.py

@@ -13,16 +13,11 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import List, Optional, Union
 
 from camel.configs.base_config import BaseConfig
 
-if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
 
-
-@dataclass(frozen=True)
 class LiteLLMConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     LiteLLM API.
@@ -88,7 +83,6 @@ class LiteLLMConfig(BaseConfig):
     user: Optional[str] = None
     response_format: Optional[dict] = None
     seed: Optional[int] = None
-    tools: Optional[list[OpenAIFunction]] = None
     tool_choice: Optional[Union[str, dict]] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
@@ -100,4 +94,4 @@ class LiteLLMConfig(BaseConfig):
     max_retries: Optional[int] = None
 
 
-LITELLM_API_PARAMS = {param for param in asdict(LiteLLMConfig()).keys()}
+LITELLM_API_PARAMS = {param for param in LiteLLMConfig.model_fields.keys()}

camel/configs/mistral_config.py

@@ -0,0 +1,78 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from pydantic import field_validator
+
+from camel.configs.base_config import BaseConfig
+
+
+class MistralConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Mistral API.
+
+    reference: https://github.com/mistralai/client-python/blob/9d238f88c41689821d7b08570f13b43426f97fd6/src/mistralai/client.py#L195
+
+    Args:
+        temperature (Optional[float], optional): temperature the temperature
+            to use for sampling, e.g. 0.5.
+        max_tokens (Optional[int], optional): the maximum number of tokens to
+            generate, e.g. 100. Defaults to None.
+        top_p (Optional[float], optional): the cumulative probability of
+            tokens to generate, e.g. 0.9. Defaults to None.
+        random_seed (Optional[int], optional): the random seed to use for
+            sampling, e.g. 42. Defaults to None.
+        safe_mode (bool, optional): deprecated, use safe_prompt instead.
+            Defaults to False.
+        safe_prompt (bool, optional): whether to use safe prompt, e.g. true.
+            Defaults to False.
+        response_format (Union[Dict[str, str], ResponseFormat): format of the
+            response.
+        tools (Optional[list[OpenAIFunction]], optional): a list of tools to
+            use.
+        tool_choice (str, optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"any"` means the
+            model must call one or more tools. :obj:`"auto"` is the default
+            value.
+    """
+
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    random_seed: Optional[int] = None
+    safe_mode: bool = False
+    safe_prompt: bool = False
+    response_format: Optional[Union[Dict[str, str], Any]] = None
+    tool_choice: Optional[str] = "auto"
+
+    @field_validator("response_format", mode="before")
+    @classmethod
+    def fields_type_checking(cls, response_format):
+        if response_format and not isinstance(response_format, dict):
+            from mistralai.models.chat_completion import ResponseFormat
+
+            if not isinstance(response_format, ResponseFormat):
+                raise ValueError(
+                    f"The tool {response_format} should be an instance "
+                    "of `mistralai.models.chat_completion.ResponseFormat`."
+                )
+        return response_format
+
+
+MISTRAL_API_PARAMS = {param for param in MistralConfig().model_fields.keys()}

camel/configs/ollama_config.py

@@ -13,15 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import Sequence
+from typing import Sequence, Union
 
 from openai._types import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class OllamaConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using OpenAI
     compatibility
@@ -75,11 +73,11 @@ class OllamaConfig(BaseConfig):
     temperature: float = 0.2
     top_p: float = 1.0
     stream: bool = False
-    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
-    max_tokens: int | NotGiven = NOT_GIVEN
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
     presence_penalty: float = 0.0
-    response_format: dict | NotGiven = NOT_GIVEN
+    response_format: Union[dict, NotGiven] = NOT_GIVEN
     frequency_penalty: float = 0.0
 
 
-OLLAMA_API_PARAMS = {param for param in asdict(OllamaConfig()).keys()}
+OLLAMA_API_PARAMS = {param for param in OllamaConfig.model_fields.keys()}