Merge remote-tracking branch 'origin/master' into terminate-chatagent

Author: a7m-1st

.github/workflows/build_package.yml

@@ -10,10 +10,15 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Clean up before build
+      - name: Free disk space
         run: |
           sudo apt-get clean
+          sudo apt-get autoremove -y
           sudo rm -rf /var/lib/apt/lists/*
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /usr/local/share/boost
+          sudo rm -rf /usr/local/lib/android
           sudo rm -rf /tmp/*
           sudo rm -rf $HOME/.cache/pip
           df -h
@@ -30,17 +35,38 @@ jobs:
       - name: Create virtual environment
         run: |
           uv venv .venv --python=3.10
+          df -h
 
-      - name: Install dependencies
+      - name: Install core dependencies
         run: |
           source .venv/bin/activate
-          uv pip install -e ".[all, dev, docs]"
+          # Install just the core dependencies first
+          uv pip install -e "."
+          df -h
 
-      - name: Build
+      - name: Install dev dependencies
+        run: |
+          source .venv/bin/activate
+          # Install dev dependencies separately
+          uv pip install -e ".[dev]"
+          df -h
+
+      - name: Install docs dependencies
+        run: |
+          source .venv/bin/activate
+          # Install docs dependencies separately
+          uv pip install -e ".[docs]"
+          df -h
+
+      - name: Install build tools
         run: |
           source .venv/bin/activate
-          uv pip install -e ".[all, dev, docs]"
           uv pip install build
+          df -h
+
+      - name: Build
+        run: |
+          source .venv/bin/activate
           python -m build
 
       - name: Set up test environment
@@ -108,6 +134,8 @@ jobs:
           BEDROCK_API_BASE_URL: "${{ secrets.BEDROCK_API_BASE_URL }}"
           NETMIND_API_KEY: "${{ secrets.NETMIND_API_KEY }}"
           NOVITA_API_KEY: "${{ secrets.NOVITA_API_KEY }}"
+          WATSONX_API_KEY: "${{ secrets.WATSONX_API_KEY }}"
+          WATSONX_PROJECT_ID: "${{ secrets.WATSONX_PROJECT_ID }}"
         run: |
           source test_venv/bin/activate
           pytest --fast-test-mode ./test
@@ -116,7 +144,12 @@ jobs:
         if: always()
         run: |
           sudo apt-get clean
+          sudo apt-get autoremove -y
           sudo rm -rf /var/lib/apt/lists/*
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /usr/local/share/boost
+          sudo rm -rf /usr/local/lib/android
           sudo rm -rf /tmp/*
           sudo rm -rf $HOME/.cache/pip
           df -h

.github/workflows/pytest_package.yml

@@ -73,6 +73,8 @@ jobs:
         BEDROCK_API_BASE_URL: "${{ secrets.BEDROCK_API_BASE_URL }}"
         NETMIND_API_KEY: "${{ secrets.NETMIND_API_KEY }}"
         NOVITA_API_KEY: "${{ secrets.NOVITA_API_KEY }}"
+        WATSONX_API_KEY: "${{ secrets.WATSONX_API_KEY }}"
+        WATSONX_PROJECT_ID: "${{ secrets.WATSONX_PROJECT_ID }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"
@@ -138,6 +140,8 @@ jobs:
         BEDROCK_API_BASE_URL: "${{ secrets.BEDROCK_API_BASE_URL }}"
         NETMIND_API_KEY: "${{ secrets.NETMIND_API_KEY }}"
         NOVITA_API_KEY: "${{ secrets.NOVITA_API_KEY }}"
+        WATSONX_API_KEY: "${{ secrets.WATSONX_API_KEY }}"
+        WATSONX_PROJECT_ID: "${{ secrets.WATSONX_PROJECT_ID }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"
@@ -201,6 +205,8 @@ jobs:
         BEDROCK_API_BASE_URL: "${{ secrets.BEDROCK_API_BASE_URL }}"
         NETMIND_API_KEY: "${{ secrets.NETMIND_API_KEY }}"
         NOVITA_API_KEY: "${{ secrets.NOVITA_API_KEY }}"
+        WATSONX_API_KEY: "${{ secrets.WATSONX_API_KEY }}"
+        WATSONX_PROJECT_ID: "${{ secrets.WATSONX_PROJECT_ID }}"
       run: |
         source .venv/bin/activate
         uv pip install -e ".[all, dev, docs]"

camel/agents/chat_agent.py

@@ -28,6 +28,7 @@
     List,
     Optional,
     Set,
+    Tuple,
     Type,
     Union,
 )
@@ -78,7 +79,6 @@
 if TYPE_CHECKING:
     from camel.terminators import ResponseTerminator
 
-
 logger = logging.getLogger(__name__)
 
 # AgentOps decorator setting
@@ -110,10 +110,17 @@ class ChatAgent(BaseAgent):
 
     Args:
         system_message (Union[BaseMessage, str], optional): The system message
-            for the chat agent.
-        model (BaseModelBackend, optional): The model backend to use for
-            generating responses. (default: :obj:`ModelPlatformType.DEFAULT`
-            with `ModelType.DEFAULT`)
+            for the chat agent. (default: :obj:`None`)
+        model (Union[BaseModelBackend, Tuple[str, str], str, ModelType,
+            Tuple[ModelPlatformType, ModelType], List[BaseModelBackend],
+            List[str], List[ModelType], List[Tuple[str, str]],
+            List[Tuple[ModelPlatformType, ModelType]]], optional):
+            The model backend(s) to use. Can be a single instance,
+            a specification (string, enum, tuple), or a list of instances
+            or specifications to be managed by `ModelManager`. If a list of
+            specifications (not `BaseModelBackend` instances) is provided,
+            they will be instantiated using `ModelFactory`. (default:
+            :obj:`ModelPlatformType.DEFAULT` with `ModelType.DEFAULT`)
         memory (AgentMemory, optional): The agent memory for managing chat
             messages. If `None`, a :obj:`ChatHistoryMemory` will be used.
             (default: :obj:`None`)
@@ -150,7 +157,18 @@ def __init__(
         self,
         system_message: Optional[Union[BaseMessage, str]] = None,
         model: Optional[
-            Union[BaseModelBackend, List[BaseModelBackend]]
+            Union[
+                BaseModelBackend,
+                Tuple[str, str],
+                str,
+                ModelType,
+                Tuple[ModelPlatformType, ModelType],
+                List[BaseModelBackend],
+                List[str],
+                List[ModelType],
+                List[Tuple[str, str]],
+                List[Tuple[ModelPlatformType, ModelType]],
+            ]
         ] = None,
         memory: Optional[AgentMemory] = None,
         message_window_size: Optional[int] = None,
@@ -165,19 +183,14 @@ def __init__(
         single_iteration: bool = False,
         agent_id: Optional[str] = None,
     ) -> None:
-        # Set up model backend
+        # Resolve model backends and set up model manager
+        resolved_models = self._resolve_models(model)
         self.model_backend = ModelManager(
-            (
-                model
-                if model is not None
-                else ModelFactory.create(
-                    model_platform=ModelPlatformType.DEFAULT,
-                    model_type=ModelType.DEFAULT,
-                )
-            ),
+            resolved_models,
             scheduling_strategy=scheduling_strategy,
         )
         self.model_type = self.model_backend.model_type
+
         # Assign unique ID
         self.agent_id = agent_id if agent_id else str(uuid.uuid4())
 
@@ -247,6 +260,137 @@ def reset(self):
         for terminator in self.response_terminators:
             terminator.reset()
 
+    def _resolve_models(
+        self,
+        model: Optional[
+            Union[
+                BaseModelBackend,
+                Tuple[str, str],
+                str,
+                ModelType,
+                Tuple[ModelPlatformType, ModelType],
+                List[BaseModelBackend],
+                List[str],
+                List[ModelType],
+                List[Tuple[str, str]],
+                List[Tuple[ModelPlatformType, ModelType]],
+            ]
+        ],
+    ) -> Union[BaseModelBackend, List[BaseModelBackend]]:
+        r"""Resolves model specifications into model backend instances.
+
+        This method handles various input formats for model specifications and
+        returns the appropriate model backend(s).
+
+        Args:
+            model: Model specification in various formats including single
+                model, list of models, or model type specifications.
+
+        Returns:
+            Union[BaseModelBackend, List[BaseModelBackend]]: Resolved model
+                backend(s).
+
+        Raises:
+            TypeError: If the model specification format is not supported.
+        """
+        if model is None:
+            # Default single model if none provided
+            return ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
+            )
+        elif isinstance(model, BaseModelBackend):
+            # Already a single pre-instantiated model
+            return model
+        elif isinstance(model, list):
+            return self._resolve_model_list(model)
+        elif isinstance(model, (ModelType, str)):
+            # Single string or ModelType -> use default platform
+            model_platform = ModelPlatformType.DEFAULT
+            model_type = model
+            logger.warning(
+                f"Model type '{model_type}' provided without a platform. "
+                f"Using platform '{model_platform}'. Note: platform "
+                "is not automatically inferred based on model type."
+            )
+            return ModelFactory.create(
+                model_platform=model_platform,
+                model_type=model_type,
+            )
+        elif isinstance(model, tuple) and len(model) == 2:
+            # Single tuple (platform, type)
+            model_platform, model_type = model  # type: ignore[assignment]
+            return ModelFactory.create(
+                model_platform=model_platform,
+                model_type=model_type,
+            )
+        else:
+            raise TypeError(
+                f"Unsupported type for model parameter: {type(model)}"
+            )
+
+    def _resolve_model_list(
+        self, model_list: list
+    ) -> Union[BaseModelBackend, List[BaseModelBackend]]:
+        r"""Resolves a list of model specifications into model backend
+        instances.
+
+        Args:
+            model_list (list): List of model specifications in various formats.
+
+        Returns:
+            Union[BaseModelBackend, List[BaseModelBackend]]: Resolved model
+                backend(s).
+
+        Raises:
+            TypeError: If the list elements format is not supported.
+        """
+        if not model_list:  # Handle empty list
+            logger.warning(
+                "Empty list provided for model, using default model."
+            )
+            return ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
+            )
+        elif isinstance(model_list[0], BaseModelBackend):
+            # List of pre-instantiated models
+            return model_list  # type: ignore[return-value]
+        elif isinstance(model_list[0], (str, ModelType)):
+            # List of strings or ModelTypes -> use default platform
+            model_platform = ModelPlatformType.DEFAULT
+            logger.warning(
+                f"List of model types {model_list} provided without "
+                f"platforms. Using platform '{model_platform}' for all. "
+                "Note: platform is not automatically inferred based on "
+                "model type."
+            )
+            resolved_models_list = []
+            for model_type_item in model_list:
+                resolved_models_list.append(
+                    ModelFactory.create(
+                        model_platform=model_platform,
+                        model_type=model_type_item,  # type: ignore[arg-type]
+                    )
+                )
+            return resolved_models_list
+        elif isinstance(model_list[0], tuple) and len(model_list[0]) == 2:
+            # List of tuples (platform, type)
+            resolved_models_list = []
+            for model_spec in model_list:
+                platform, type_ = model_spec[0], model_spec[1]  # type: ignore[index]
+                resolved_models_list.append(
+                    ModelFactory.create(
+                        model_platform=platform, model_type=type_
+                    )
+                )
+            return resolved_models_list
+        else:
+            raise TypeError(
+                "Unsupported type for list elements in model: "
+                f"{type(model_list[0])}"
+            )
+
     @property
     def system_message(self) -> Optional[BaseMessage]:
         r"""Returns the system message for the agent."""

camel/configs/__init__.py

@@ -44,6 +44,7 @@
 from .siliconflow_config import SILICONFLOW_API_PARAMS, SiliconFlowConfig
 from .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfig
 from .vllm_config import VLLM_API_PARAMS, VLLMConfig
+from .watsonx_config import WATSONX_API_PARAMS, WatsonXConfig
 from .yi_config import YI_API_PARAMS, YiConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
@@ -109,4 +110,6 @@
     'OPENROUTER_API_PARAMS',
     'LMSTUDIO_API_PARAMS',
     'LMStudioConfig',
+    'WatsonXConfig',
+    'WATSONX_API_PARAMS',
 ]

camel/configs/qwen_config.py

@@ -80,12 +80,5 @@ class QwenConfig(BaseConfig):
     stop: Optional[Union[str, List]] = None
     extra_body: Optional[Dict[str, Any]] = None
 
-    def __init__(self, include_usage: bool = True, **kwargs):
-        super().__init__(**kwargs)
-        # Only set stream_options when stream is True
-        # Otherwise, it will raise error when calling the API
-        if self.stream:
-            self.stream_options = {"include_usage": include_usage}
-
 
 QWEN_API_PARAMS = {param for param in QwenConfig.model_fields.keys()}