yaicli 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.6.3"
+version = "0.7.0"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"
@@ -42,6 +42,15 @@ keywords = [
     "anthropic",
     "groq",
     "cohere",
+    "huggingface",
+    "chatglm",
+    "sambanova",
+    "siliconflow",
+    "xai",
+    "vertexai",
+    "deepseek",
+    "modelscope",
+    "ollama",
 ]
 dependencies = [
     "click>=8.1.8",
@@ -70,11 +79,15 @@ all = [
     "ollama>=0.5.1",
     "cohere>=5.15.0",
     "google-genai>=1.20.0",
+    "huggingface-hub>=0.33.0",
 ]
 doubao = ["volcengine-python-sdk>=3.0.15"]
 ollama = ["ollama>=0.5.1"]
 cohere = ["cohere>=5.15.0"]
 gemini = ["google-genai>=1.20.0"]
+huggingface = [
+    "huggingface-hub>=0.33.0",
+]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

yaicli/cli.py

@@ -267,7 +267,7 @@ class CLI:
                     assistant_msg = self.chat.history[i + 1] if (i + 1) < len(self.chat.history) else None
                     self.console.print(f"[dim]{i // 2 + 1}[/dim] [bold blue]User:[/bold blue] {user_msg.content}")
                     if assistant_msg:
-                        md = Markdown(assistant_msg.content, code_theme=cfg["CODE_THEME"])
+                        md = Markdown(assistant_msg.content or "", code_theme=cfg["CODE_THEME"])
                         padded_md = Padding(md, (0, 0, 0, 4))
                         self.console.print("    Assistant:", style="bold green")
                         self.console.print(padded_md)
@@ -384,7 +384,7 @@ class CLI:
         self._check_history_len()
 
         if self.current_mode == EXEC_MODE:
-            self._confirm_and_execute(content)
+            self._confirm_and_execute(content or "")
         return True
 
     def _confirm_and_execute(self, raw_content: str) -> None:

yaicli/config.py

@@ -142,7 +142,7 @@ class Config(dict):
                 if target_type is bool:
                     converted_value = str2bool(raw_value)
                 elif target_type in (int, float, str):
-                    converted_value = target_type(raw_value)
+                    converted_value = target_type(raw_value) if raw_value else raw_value
                 elif target_type is dict and raw_value:
                     converted_value = json.loads(raw_value)
             except (ValueError, TypeError, json.JSONDecodeError) as e:

yaicli/const.py

@@ -1,5 +1,5 @@
 try:
-    from enum import StrEnum
+    from enum import StrEnum  # type: ignore
 except ImportError:
     from enum import Enum
 
@@ -16,7 +16,7 @@ from rich.console import JustifyMethod
 BOOL_STR = Literal["true", "false", "yes", "no", "y", "n", "1", "0", "on", "off"]
 
 
-class JustifyEnum(StrEnum):
+class JustifyEnum(StrEnum):  # type: ignore
     DEFAULT = "default"
     LEFT = "left"
     CENTER = "center"
@@ -43,6 +43,7 @@ HISTORY_FILE = Path("~/.yaicli_history").expanduser()
 CONFIG_PATH = Path("~/.config/yaicli/config.ini").expanduser()
 ROLES_DIR = CONFIG_PATH.parent / "roles"
 FUNCTIONS_DIR = CONFIG_PATH.parent / "functions"
+MCP_JSON_PATH = CONFIG_PATH.parent / "mcp.json"
 
 # Default configuration values
 DEFAULT_CODE_THEME = "monokai"
@@ -68,7 +69,9 @@ DEFAULT_JUSTIFY: JustifyMethod = "default"
 DEFAULT_ROLE_MODIFY_WARNING: BOOL_STR = "true"
 DEFAULT_ENABLE_FUNCTIONS: BOOL_STR = "true"
 DEFAULT_SHOW_FUNCTION_OUTPUT: BOOL_STR = "true"
-DEFAULT_REASONING_EFFORT: Optional[Literal["low", "high", "medium"]] = ""
+DEFAULT_REASONING_EFFORT: Optional[Literal["low", "high", "medium"]] = None
+DEFAULT_ENABLE_MCP: BOOL_STR = "false"
+DEFAULT_SHOW_MCP_OUTPUT: BOOL_STR = "false"
 
 
 SHELL_PROMPT = """You are YAICLI, a shell command generator.
@@ -93,16 +96,16 @@ CODER_PROMPT = (
 )
 
 
-class DefaultRoleNames(StrEnum):
+class DefaultRoleNames(StrEnum):  # type: ignore
     SHELL = "Shell Command Generator"
     DEFAULT = "DEFAULT"
     CODER = "Code Assistant"
 
 
 DEFAULT_ROLES: dict[str, dict[str, Any]] = {
-    DefaultRoleNames.SHELL.value: {"name": DefaultRoleNames.SHELL.value, "prompt": SHELL_PROMPT},
-    DefaultRoleNames.DEFAULT.value: {"name": DefaultRoleNames.DEFAULT.value, "prompt": DEFAULT_PROMPT},
-    DefaultRoleNames.CODER.value: {"name": DefaultRoleNames.CODER.value, "prompt": CODER_PROMPT},
+    DefaultRoleNames.SHELL.value: {"name": DefaultRoleNames.SHELL.value, "prompt": SHELL_PROMPT},  # type: ignore
+    DefaultRoleNames.DEFAULT.value: {"name": DefaultRoleNames.DEFAULT.value, "prompt": DEFAULT_PROMPT},  # type: ignore
+    DefaultRoleNames.CODER.value: {"name": DefaultRoleNames.CODER.value, "prompt": CODER_PROMPT},  # type: ignore
 }
 
 # DEFAULT_CONFIG_MAP is a dictionary of the configuration options.
@@ -151,6 +154,8 @@ DEFAULT_CONFIG_MAP = {
         "env_key": "YAI_SHOW_FUNCTION_OUTPUT",
         "type": bool,
     },
+    "ENABLE_MCP": {"value": DEFAULT_ENABLE_MCP, "env_key": "YAI_ENABLE_MCP", "type": bool},
+    "SHOW_MCP_OUTPUT": {"value": DEFAULT_SHOW_MCP_OUTPUT, "env_key": "YAI_SHOW_MCP_OUTPUT", "type": bool},
 }
 
 DEFAULT_CONFIG_INI = f"""[core]
@@ -201,6 +206,12 @@ ROLE_MODIFY_WARNING={DEFAULT_CONFIG_MAP["ROLE_MODIFY_WARNING"]["value"]}
 # Function settings
 # Set to false to disable sending functions in API requests
 ENABLE_FUNCTIONS={DEFAULT_CONFIG_MAP["ENABLE_FUNCTIONS"]["value"]}
-# Set to false to disable showing function output in the response
+# Set to false to disable showing function output when calling functions
 SHOW_FUNCTION_OUTPUT={DEFAULT_CONFIG_MAP["SHOW_FUNCTION_OUTPUT"]["value"]}
+
+# MCP settings
+# Set to false to disable MCP in API requests
+ENABLE_MCP={DEFAULT_CONFIG_MAP["ENABLE_MCP"]["value"]}
+# Set to false to disable showing MCP output when calling MCP tools
+SHOW_MCP_OUTPUT={DEFAULT_CONFIG_MAP["SHOW_MCP_OUTPUT"]["value"]}
 """

yaicli/entry.py

@@ -6,7 +6,7 @@ import typer
 from .chat import FileChatManager
 from .config import cfg
 from .const import DEFAULT_CONFIG_INI, DefaultRoleNames, JustifyEnum
-from .functions import install_functions, print_functions
+from .functions import install_functions, print_functions, print_mcp
 from .role import RoleManager
 
 app = typer.Typer(
@@ -209,6 +209,29 @@ def main(
         show_default=False,
         callback=override_config,
     ),
+    # ------------------- MCP Options -------------------
+    enable_mcp: bool = typer.Option(  # noqa: F841
+        cfg["ENABLE_MCP"],
+        "--enable-mcp/--disable-mcp",
+        help=f"Enable/disable MCP in API requests [dim](default: {'enabled' if cfg['ENABLE_MCP'] else 'disabled'})[/dim]",
+        rich_help_panel="MCP Options",
+        callback=override_config,
+    ),
+    show_mcp_output: bool = typer.Option(  # noqa: F841
+        cfg["SHOW_MCP_OUTPUT"],
+        "--show-mcp-output/--hide-mcp-output",
+        help=f"Show the output of MCP [dim](default: {'show' if cfg['SHOW_MCP_OUTPUT'] else 'hide'})[/dim]",
+        rich_help_panel="MCP Options",
+        show_default=False,
+        callback=override_config,
+    ),
+    list_mcp: bool = typer.Option(  # noqa: F841
+        False,
+        "--list-mcp",
+        help="List all available mcp.",
+        rich_help_panel="MCP Options",
+        callback=print_mcp,
+    ),
 ):
     """YAICLI: Your AI assistant in the command line.
 

yaicli/functions/__init__.py

@@ -1,9 +1,10 @@
+import json
 import shutil
 from pathlib import Path
 from typing import Any
 
 from ..console import get_console
-from ..const import FUNCTIONS_DIR
+from ..const import FUNCTIONS_DIR, MCP_JSON_PATH
 from ..utils import option_callback
 
 console = get_console()
@@ -37,3 +38,14 @@ def print_functions(cls, _: Any) -> None:
         if file.name.startswith("_"):
             continue
         console.print(file)
+
+
+@option_callback
+def print_mcp(cls, _: Any) -> None:
+    """List all available mcp"""
+    if not MCP_JSON_PATH.exists():
+        console.print("No mcp config found, please add your mcp config in ~/.config/yaicli/mcp.json")
+        return
+    with open(MCP_JSON_PATH, "r") as f:
+        mcp_config = json.load(f)
+    console.print_json(data=mcp_config)

yaicli/llms/client.py

@@ -4,6 +4,7 @@ from ..config import cfg
 from ..console import get_console
 from ..schemas import ChatMessage, LLMResponse, RefreshLive, ToolCall
 from ..tools import execute_tool_call
+from ..tools.mcp import MCP_TOOL_NAME_PREFIX
 from .provider import Provider, ProviderFactory
 
 
@@ -37,6 +38,8 @@ class LLMClient:
         self.config = config
         self.verbose = verbose
         self.console = get_console()
+        self.enable_function = self.config["ENABLE_FUNCTIONS"]
+        self.enable_mcp = self.config["ENABLE_MCP"]
 
         # Use provided provider or create one
         if provider:
@@ -73,48 +76,78 @@ class LLMClient:
             )
             return
 
-        # Get completion from provider
-        llm_response_generator = self.provider.completion(messages, stream=stream)
-
-        # To hold the full response
+        # Get completion from provider and collect response data
         assistant_response_content = ""
-        tool_calls: List[ToolCall] = []
+        # Providers may return identical tool calls with the same ID in a single response during streaming
+        tool_calls: dict[str, ToolCall] = {}
 
-        # Process all responses from the provider
-        for llm_response in llm_response_generator:
-            # Forward the response to the caller
-            yield llm_response
+        # Stream responses and collect data
+        for llm_response in self.provider.completion(messages, stream=stream):
+            yield llm_response  # Forward response to caller
 
-            # Collect content and tool calls
+            # Collect content and tool calls for potential tool execution
             if llm_response.content:
                 assistant_response_content += llm_response.content
-            if llm_response.tool_call and llm_response.tool_call not in tool_calls:
-                tool_calls.append(llm_response.tool_call)
-
-        # If we have tool calls, execute them and make recursive call
-        if tool_calls and self.config["ENABLE_FUNCTIONS"]:
-            # Yield a refresh signal to indicate new content is coming
-            yield RefreshLive()
-
-            # Append the assistant message with tool calls to history
-            messages.append(ChatMessage(role="assistant", content=assistant_response_content, tool_calls=tool_calls))
-
-            # Execute each tool call and append the results
-            for tool_call in tool_calls:
-                function_result, _ = execute_tool_call(tool_call)
-
-                # Use provider's tool role detection
-                tool_role = self.provider.detect_tool_role()
-
-                # Append the tool result to history
-                messages.append(
-                    ChatMessage(
-                        role=tool_role,
-                        content=function_result,
-                        name=tool_call.name,
-                        tool_call_id=tool_call.id,
-                    )
+            if llm_response.tool_call and llm_response.tool_call.id not in tool_calls:
+                tool_calls[llm_response.tool_call.id] = llm_response.tool_call
+
+        # Check if we need to execute tools
+        if not tool_calls or not (self.enable_function or self.enable_mcp):
+            return
+
+        # Filter valid tool calls based on enabled features
+        valid_tool_calls = self._get_valid_tool_calls(tool_calls)
+        if not valid_tool_calls:
+            return
+
+        # Execute tools and continue conversation
+        yield from self._execute_tools_and_continue(
+            messages, assistant_response_content, valid_tool_calls, stream, recursion_depth
+        )
+
+    def _get_valid_tool_calls(self, tool_calls: dict[str, ToolCall]) -> List[ToolCall]:
+        """Filter tool calls based on enabled features"""
+        valid_tool_calls = []
+
+        for tool_call in tool_calls.values():
+            is_mcp = tool_call.name.startswith(MCP_TOOL_NAME_PREFIX)
+
+            if is_mcp and self.enable_mcp:
+                valid_tool_calls.append(tool_call)
+            elif not is_mcp and self.enable_function:
+                valid_tool_calls.append(tool_call)
+
+        return valid_tool_calls
+
+    def _execute_tools_and_continue(
+        self,
+        messages: List[ChatMessage],
+        assistant_response_content: str,
+        tool_calls: List[ToolCall],
+        stream: bool,
+        recursion_depth: int,
+    ) -> Generator[Union[LLMResponse, RefreshLive], None, None]:
+        """Execute tool calls and continue the conversation"""
+        # Signal that new content is coming
+        yield RefreshLive()
+
+        # Add assistant message with tool calls to history (only once)
+        messages.append(ChatMessage(role="assistant", content=assistant_response_content, tool_calls=tool_calls))
+
+        # Execute each tool call and add results to messages
+        tool_role = self.provider.detect_tool_role()
+
+        for tool_call in tool_calls:
+            function_result, _ = execute_tool_call(tool_call)
+
+            messages.append(
+                ChatMessage(
+                    role=tool_role,
+                    content=function_result,
+                    name=tool_call.name,
+                    tool_call_id=tool_call.id,
                 )
+            )
 
-            # Make a recursive call with the updated history
-            yield from self.completion_with_tools(messages, stream=stream, recursion_depth=recursion_depth + 1)
+        # Continue the conversation with updated history
+        yield from self.completion_with_tools(messages, stream=stream, recursion_depth=recursion_depth + 1)

yaicli/llms/provider.py

@@ -43,10 +43,13 @@ class ProviderFactory:
         "chatglm": (".providers.chatglm_provider", "ChatglmProvider"),
         "chutes": (".providers.chutes_provider", "ChutesProvider"),
         "cohere": (".providers.cohere_provider", "CohereProvider"),
+        "cohere-bedrock": (".providers.cohere_provider", "CohereBadrockProvider"),
+        "cohere-sagemaker": (".providers.cohere_provider", "CohereSagemakerProvider"),
         "deepseek": (".providers.deepseek_provider", "DeepSeekProvider"),
         "doubao": (".providers.doubao_provider", "DoubaoProvider"),
         "gemini": (".providers.gemini_provider", "GeminiProvider"),
         "groq": (".providers.groq_provider", "GroqProvider"),
+        "huggingface": (".providers.huggingface_provider", "HuggingFaceProvider"),
         "infini-ai": (".providers.infiniai_provider", "InfiniAIProvider"),
         "minimax": (".providers.minimax_provider", "MinimaxProvider"),
         "modelscope": (".providers.modelscope_provider", "ModelScopeProvider"),

yaicli/llms/providers/ai21_provider.py

@@ -63,7 +63,7 @@ class AI21Provider(OpenAIProvider):
             if finish_reason == "tool_calls" and not content:
                 # tool call assistant message, content can't be empty
                 # Error code: 422 - {'detail': {'error': ['Value error, message content must not be an empty string']}}
-                content = tool_call.id
+                content = tool_call.id if tool_call else ""
 
             # Generate response object
             yield LLMResponse(
@@ -72,3 +72,35 @@ class AI21Provider(OpenAIProvider):
                 tool_call=tool_call if finish_reason == "tool_calls" else None,
                 finish_reason=finish_reason,
             )
+
+    def _process_tool_call_chunk(self, tool_calls, existing_tool_call=None):
+        """Process a tool call chunk from AI21 API response
+
+        Tool calls from AI21 are delivered across multiple chunks:
+        - First chunk contains function name
+        - Subsequent chunks contain arguments data
+        - Final chunk (with finish_reason='tool_calls') contains complete arguments
+
+        Args:
+            tool_calls: Tool call data from current chunk
+            existing_tool_call: Previously accumulated tool call object
+
+        Returns:
+            ToolCall: Updated tool call object with accumulated data
+        """
+        # Get the first (and only) tool call from the chunk
+        call = tool_calls[0]
+
+        if existing_tool_call is None:
+            # First chunk - create new tool call with function name
+            return ToolCall(id=call.id, name=call.function.name, arguments="{}")
+        else:
+            # Update existing tool call with new arguments data
+            # Keep existing data and update with new information
+            existing_arguments = existing_tool_call.arguments
+            new_arguments = call.function.arguments if hasattr(call.function, "arguments") else "{}"
+
+            # Combine arguments (new arguments should override if available)
+            combined_arguments = new_arguments if new_arguments else existing_arguments
+
+            return ToolCall(id=existing_tool_call.id, name=existing_tool_call.name, arguments=combined_arguments)

yaicli/llms/providers/chatglm_provider.py

@@ -1,9 +1,10 @@
 import json
-from typing import Any, Dict, Generator, Optional
+from typing import Generator, Optional, Union, overload
 
 from openai._streaming import Stream
 from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_chunk import Choice as ChoiceChunk
 
 from ...schemas import LLMResponse, ToolCall
 from .openai_provider import OpenAIProvider
@@ -14,10 +15,14 @@ class ChatglmProvider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"
 
-    def get_completion_params(self) -> Dict[str, Any]:
-        params = super().get_completion_params()
-        params["max_tokens"] = params.pop("max_completion_tokens")
-        return params
+    COMPLETION_PARAMS_KEYS = {
+        "model": "MODEL",
+        "temperature": "TEMPERATURE",
+        "top_p": "TOP_P",
+        "max_tokens": "MAX_TOKENS",
+        "do_sample": "DO_SAMPLE",
+        "extra_body": "EXTRA_BODY",
+    }
 
     def _handle_normal_response(self, response: ChatCompletion) -> Generator[LLMResponse, None, None]:
         """Handle normal (non-streaming) response
@@ -57,7 +62,7 @@ class ChatglmProvider(OpenAIProvider):
                     tmp_content = content[tool_index:]
                     # Tool call data may in content after the <think> block
                     try:
-                        choice = self.parse_choice_from_content(tmp_content)
+                        choice = self.parse_choice_from_content(tmp_content, Choice)
                     except ValueError:
                         pass
             if hasattr(choice, "message") and hasattr(choice.message, "tool_calls") and choice.message.tool_calls:  # type: ignore
@@ -97,8 +102,6 @@ class ChatglmProvider(OpenAIProvider):
             reasoning = self._get_reasoning_content(delta)
             full_reasoning += reasoning or ""
 
-            if finish_reason:
-                pass
             if finish_reason == "tool_calls" or ('{"index":' in content or '"tool_calls":' in content):
                 # Tool call data may in content after the <think> block
                 # >/n{"index": 0, "tool_call_id": "call_1", "function": {"name": "name", "arguments": "{}"}, "output": null}
@@ -106,7 +109,7 @@ class ChatglmProvider(OpenAIProvider):
                 if tool_index != -1:
                     tmp_content = full_content[tool_index:]
                     try:
-                        choice = self.parse_choice_from_content(tmp_content)
+                        choice = self.parse_choice_from_content(tmp_content, ChoiceChunk)
                     except ValueError:
                         pass
             if hasattr(choice.delta, "tool_calls") and choice.delta.tool_calls:  # type: ignore
@@ -120,7 +123,31 @@ class ChatglmProvider(OpenAIProvider):
                 tool_call = ToolCall(tool_id, tool_call_name, arguments)
             yield LLMResponse(reasoning=reasoning, content=content, tool_call=tool_call, finish_reason=finish_reason)
 
-    def parse_choice_from_content(self, content: str) -> "Choice":
+    @overload
+    def parse_choice_from_content(self, content: str, choice_class: type[ChoiceChunk] = ChoiceChunk) -> "ChoiceChunk":
+        """
+        Parse the choice from the content after <think>...</think> block.
+        Args:
+            content: The content from the LLM response
+        Returns:
+            The choice object
+        Raises ValueError if the content is not valid JSON
+        """
+
+    @overload
+    def parse_choice_from_content(self, content: str, choice_class: type[Choice] = Choice) -> "Choice":
+        """
+        Parse the choice from the content after <think>...</think> block.
+        Args:
+            content: The content from the LLM response
+        Returns:
+            The choice object
+        Raises ValueError if the content is not valid JSON
+        """
+
+    def parse_choice_from_content(
+        self, content: str, choice_class: type[Union[Choice, ChoiceChunk]] = Choice
+    ) -> Union[Choice, ChoiceChunk]:
         """
         Parse the choice from the content after <think>...</think> block.
         Args:
@@ -134,6 +161,6 @@ class ChatglmProvider(OpenAIProvider):
         except json.JSONDecodeError:
             raise ValueError(f"Invalid message from LLM: {content}")
         try:
-            return Choice.model_validate(content_dict)
+            return choice_class.model_validate(content_dict)
         except Exception as e:
             raise ValueError(f"Invalid message from LLM: {content}") from e

yaicli/llms/providers/cohere_provider.py

@@ -10,7 +10,8 @@ This module implements Cohere provider classes for different deployment options:
 from typing import Any, Dict, Generator, List, Optional
 
 from cohere import BedrockClientV2, ClientV2, SagemakerClientV2
-from cohere.types.tool_call_v2 import ToolCallV2, ToolCallV2Function
+from cohere.types.tool_call_v2 import ToolCallV2
+from cohere.types.tool_call_v2function import ToolCallV2Function
 
 from ...config import cfg
 from ...console import get_console
@@ -179,7 +180,9 @@ class CohereProvider(Provider):
                 continue
             elif chunk.type == "tool-call-delta":
                 # Tool call arguments being generated: cohere.types.chat_tool_call_delta_event_delta_message.ChatToolCallDeltaEventDeltaMessage
-                tool_call.arguments += chunk.delta.message.tool_calls.function.arguments
+                if not tool_call:
+                    continue
+                tool_call.arguments += chunk.delta.message.tool_calls.function.arguments or ""
                 # Waiting for tool-call-end event
                 continue
 
@@ -292,7 +295,7 @@ class CohereBadrockProvider(CohereProvider):
         return self.CLIENT_CLS(**self.client_params)
 
 
-class CohereSagemaker(CohereBadrockProvider):
+class CohereSagemakerProvider(CohereBadrockProvider):
     """Cohere provider for AWS Sagemaker integration"""
 
     CLIENT_CLS = SagemakerClientV2

yaicli/llms/providers/deepseek_provider.py

@@ -10,5 +10,6 @@ class DeepSeekProvider(OpenAIProvider):
 
     def get_completion_params(self) -> Dict[str, Any]:
         params = super().get_completion_params()
-        params["max_tokens"] = params.pop("max_completion_tokens")
+        if "max_completion_tokens" in params:
+            params["max_tokens"] = params.pop("max_completion_tokens")
         return params

yaicli/llms/providers/doubao_provider.py

@@ -2,8 +2,6 @@ from typing import Any, Dict
 
 from volcenginesdkarkruntime import Ark
 
-from ...config import cfg
-from ...console import get_console
 from .openai_provider import OpenAIProvider
 
 
@@ -13,18 +11,6 @@ class DoubaoProvider(OpenAIProvider):
     DEFAULT_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
     CLIENT_CLS = Ark
 
-    def __init__(self, config: dict = cfg, **kwargs):
-        self.config = config
-        self.enable_function = self.config["ENABLE_FUNCTIONS"]
-        self.client_params = self.get_client_params()
-
-        # Initialize client
-        self.client = self.CLIENT_CLS(**self.client_params)
-        self.console = get_console()
-
-        # Store completion params
-        self.completion_params = self.get_completion_params()
-
     def get_client_params(self) -> Dict[str, Any]:
         # Initialize client params
         client_params = {"base_url": self.DEFAULT_BASE_URL}