yaicli 0.6.4__py3-none-any.whl → 0.7.1__py3-none-any.whl

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.6.4"
+version = "0.7.1"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"
@@ -55,6 +55,7 @@ keywords = [
 dependencies = [
     "click>=8.1.8",
     "distro>=1.9.0",
+    "fastmcp>=2.9.2",
     "httpx>=0.28.1",
     "instructor>=1.7.9",
     "json-repair>=0.44.1",
@@ -88,6 +89,9 @@ gemini = ["google-genai>=1.20.0"]
 huggingface = [
     "huggingface-hub>=0.33.0",
 ]
+mistral = [
+    "mistralai>=1.8.2",
+]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

yaicli/const.py

@@ -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"
@@ -69,6 +70,8 @@ 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"]] = 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/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 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
@@ -61,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
@@ -101,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}
@@ -110,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
@@ -124,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:
@@ -138,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/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}

yaicli/llms/providers/gemini_provider.py

@@ -1,25 +1,18 @@
 import json
-from functools import wraps
 from typing import Any, Callable, Dict, Generator, List
 
 import google.genai as genai
 from google.genai import types
 
+from yaicli.tools.mcp import get_mcp_manager
+
 from ...config import cfg
 from ...console import get_console
 from ...schemas import ChatMessage, LLMResponse
-from ...tools import get_func_name_map
+from ...tools.function import get_functions_gemini_format
 from ..provider import Provider
 
 
-def wrap_function(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 class GeminiProvider(Provider):
     """Gemini provider implementation based on google-genai library"""
 
@@ -28,6 +21,7 @@ class GeminiProvider(Provider):
     def __init__(self, config: dict = cfg, verbose: bool = False, **kwargs):
         self.config = config
         self.enable_function = self.config["ENABLE_FUNCTIONS"]
+        self.enable_mcp = self.config["ENABLE_MCP"]
         self.verbose = verbose
 
         # Initialize client
@@ -67,16 +61,17 @@ class GeminiProvider(Provider):
             config_map["frequency_penalty"] = self.config["FREQUENCY_PENALTY"]
         if self.config.get("SEED"):
             config_map["seed"] = self.config["SEED"]
-        # Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
+        # Indicates whether to include thoughts in the response.
+        # If true, thoughts are returned only if the model supports thought and thoughts are available.
         thinking_config_map = {"include_thoughts": self.config.get("INCLUDE_THOUGHTS", True)}
         if self.config.get("THINKING_BUDGET"):
             thinking_config_map["thinking_budget"] = int(self.config["THINKING_BUDGET"])
         config_map["thinking_config"] = types.ThinkingConfig(**thinking_config_map)
-        config = types.GenerateContentConfig(**config_map)
-        if self.enable_function:
+        if self.enable_function or self.enable_mcp:
             # TODO: support disable automatic function calling
             # config.automatic_function_calling = types.AutomaticFunctionCallingConfig(disable=False)
-            config.tools = self.gen_gemini_functions()
+            config_map["tools"] = self.gen_gemini_functions()
+        config = types.GenerateContentConfig(**config_map)
         return config
 
     def _convert_messages(self, messages: List[ChatMessage]) -> List[types.Content]:
@@ -103,15 +98,19 @@ class GeminiProvider(Provider):
 
     def gen_gemini_functions(self) -> List[Callable[..., Any]]:
         """Wrap Gemini functions from OpenAI functions for automatic function calling"""
-        func_name_map = get_func_name_map()
-        if not func_name_map:
-            return []
         funcs = []
-        for func_name, func in func_name_map.items():
-            wrapped_func = wrap_function(func.execute)
-            wrapped_func.__name__ = func_name
-            wrapped_func.__doc__ = func.__doc__
-            funcs.append(wrapped_func)
+
+        # Add regular functions
+        if self.enable_function:
+            funcs.extend(get_functions_gemini_format())
+
+        # Add MCP functions if enabled
+        if self.enable_mcp:
+            try:
+                mcp_tools = get_mcp_manager().to_gemini_tools()
+                funcs.extend(mcp_tools)
+            except (ImportError, Exception) as e:
+                self.console.print(f"Failed to load MCP tools for Gemini: {e}", style="red")
         return funcs
 
     def completion(

yaicli/llms/providers/huggingface_provider.py

@@ -11,7 +11,7 @@ class HuggingFaceProvider(ChatglmProvider):
     """
 
     CLIENT_CLS = InferenceClient
-    DEFAULT_PROVIDER = "hf-inference"
+    DEFAULT_PROVIDER = "auto"
 
     COMPLETION_PARAMS_KEYS = {
         "model": "MODEL",

yaicli/llms/providers/openai_provider.py

@@ -10,6 +10,7 @@ from ...config import cfg
 from ...console import get_console
 from ...schemas import ChatMessage, LLMResponse, ToolCall
 from ...tools import get_openai_schemas
+from ...tools.mcp import get_mcp_manager
 from ..provider import Provider
 
 
@@ -34,6 +35,7 @@ class OpenAIProvider(Provider):
         if not self.config.get("API_KEY"):
             raise ValueError("API_KEY is required")
         self.enable_function = self.config["ENABLE_FUNCTIONS"]
+        self.enable_mcp = self.config["ENABLE_MCP"]
         self.verbose = verbose
 
         # Initialize client
@@ -50,15 +52,12 @@ class OpenAIProvider(Provider):
         client_params = {
             "api_key": self.config["API_KEY"],
             "base_url": self.config["BASE_URL"] or self.DEFAULT_BASE_URL,
+            "default_headers": {"X-Title": self.APP_NAME, "HTTP_Referer": self.APP_REFERER},
         }
 
         # Add extra headers if set
         if self.config["EXTRA_HEADERS"]:
-            client_params["default_headers"] = {
-                **self.config["EXTRA_HEADERS"],
-                "X-Title": self.APP_NAME,
-                "HTTP-Referer": self.APP_REFERER,
-            }
+            client_params["default_headers"] = {**self.config["EXTRA_HEADERS"], **client_params["default_headers"]}
         return client_params
 
     def get_completion_params_keys(self) -> Dict[str, str]:
@@ -134,11 +133,21 @@ class OpenAIProvider(Provider):
         params = self.completion_params.copy()
         params["messages"] = openai_messages
         params["stream"] = stream
+        tools = []
 
         if self.enable_function:
-            tools = get_openai_schemas()
-            if tools:
-                params["tools"] = tools
+            tools.extend(get_openai_schemas())
+
+        # Add MCP tools if enabled
+        if self.enable_mcp:
+            try:
+                mcp_tools = get_mcp_manager().to_openai_tools()
+            except (ValueError, FileNotFoundError) as e:
+                self.console.print(f"Failed to load MCP tools: {e}", style="red")
+                mcp_tools = []
+            tools.extend(mcp_tools)
+        if tools:
+            params["tools"] = tools
 
         try:
             if stream: