update flow

app/bedrock.py

@@ -1,18 +1,15 @@
+from typing import Dict, List, Literal, Optional, Union
+import boto3
 import json
-import sys
 import time
 import uuid
 from datetime import datetime
-from typing import Dict, List, Literal, Optional
-
-import boto3
-
+import sys
 
 # Global variables to track the current tool use ID across function calls
 # Tmp solution
 CURRENT_TOOLUSE_ID = None
 
-
 # Class to handle OpenAI-style response formatting
 class OpenAIResponse:
     def __init__(self, data):
@@ -21,37 +18,31 @@ class OpenAIResponse:
             if isinstance(value, dict):
                 value = OpenAIResponse(value)
             elif isinstance(value, list):
-                value = [
-                    OpenAIResponse(item) if isinstance(item, dict) else item
-                    for item in value
-                ]
+                value = [OpenAIResponse(item) if isinstance(item, dict) else item for item in value]
             setattr(self, key, value)
 
     def model_dump(self, *args, **kwargs):
         # Convert object to dict and add timestamp
         data = self.__dict__
-        data["created_at"] = datetime.now().isoformat()
+        data['created_at'] = datetime.now().isoformat()
         return data
 
-
 # Main client class for interacting with Amazon Bedrock
 class BedrockClient:
     def __init__(self):
         # Initialize Bedrock client, you need to configure AWS env first
         try:
-            self.client = boto3.client("bedrock-runtime")
+            self.client = boto3.client('bedrock-runtime')
             self.chat = Chat(self.client)
         except Exception as e:
             print(f"Error initializing Bedrock client: {e}")
             sys.exit(1)
 
-
 # Chat interface class
 class Chat:
     def __init__(self, client):
         self.completions = ChatCompletions(client)
 
-
 # Core class handling chat completions functionality
 class ChatCompletions:
     def __init__(self, client):
@@ -61,23 +52,19 @@ class ChatCompletions:
         # Convert OpenAI function calling format to Bedrock tool format
         bedrock_tools = []
         for tool in tools:
-            if tool.get("type") == "function":
-                function = tool.get("function", {})
+            if tool.get('type') == 'function':
+                function = tool.get('function', {})
                 bedrock_tool = {
                     "toolSpec": {
-                        "name": function.get("name", ""),
-                        "description": function.get("description", ""),
+                        "name": function.get('name', ''),
+                        "description": function.get('description', ''),
                         "inputSchema": {
                             "json": {
                                 "type": "object",
-                                "properties": function.get("parameters", {}).get(
-                                    "properties", {}
-                                ),
-                                "required": function.get("parameters", {}).get(
-                                    "required", []
-                                ),
+                                "properties": function.get('parameters', {}).get('properties', {}),
+                                "required": function.get('parameters', {}).get('required', [])
                             }
-                        },
+                        }
                     }
                 }
                 bedrock_tools.append(bedrock_tool)
@@ -88,43 +75,41 @@ class ChatCompletions:
         bedrock_messages = []
         system_prompt = []
         for message in messages:
-            if message.get("role") == "system":
-                system_prompt = [{"text": message.get("content")}]
-            elif message.get("role") == "user":
+            if message.get('role') == 'system':
+                system_prompt = [{"text": message.get('content')}]
+            elif message.get('role') == 'user':
                 bedrock_message = {
-                    "role": message.get("role", "user"),
-                    "content": [{"text": message.get("content")}],
+                    "role": message.get('role', 'user'),
+                    "content": [{"text": message.get('content')}]
                 }
                 bedrock_messages.append(bedrock_message)
-            elif message.get("role") == "assistant":
+            elif message.get('role') == 'assistant':
                 bedrock_message = {
                     "role": "assistant",
-                    "content": [{"text": message.get("content")}],
+                    "content": [{"text": message.get('content')}]
                 }
-                openai_tool_calls = message.get("tool_calls", [])
+                openai_tool_calls = message.get('tool_calls', [])
                 if openai_tool_calls:
                     bedrock_tool_use = {
-                        "toolUseId": openai_tool_calls[0]["id"],
-                        "name": openai_tool_calls[0]["function"]["name"],
-                        "input": json.loads(
-                            openai_tool_calls[0]["function"]["arguments"]
-                        ),
+                        "toolUseId": openai_tool_calls[0]['id'],
+                        "name": openai_tool_calls[0]['function']['name'],
+                        "input": json.loads(openai_tool_calls[0]['function']['arguments'])
                     }
-                    bedrock_message["content"].append({"toolUse": bedrock_tool_use})
+                    bedrock_message['content'].append({"toolUse": bedrock_tool_use})
                     global CURRENT_TOOLUSE_ID
-                    CURRENT_TOOLUSE_ID = openai_tool_calls[0]["id"]
+                    CURRENT_TOOLUSE_ID = openai_tool_calls[0]['id']
                 bedrock_messages.append(bedrock_message)
-            elif message.get("role") == "tool":
+            elif message.get('role') == 'tool':
                 bedrock_message = {
                     "role": "user",
                     "content": [
                         {
                             "toolResult": {
                                 "toolUseId": CURRENT_TOOLUSE_ID,
-                                "content": [{"text": message.get("content")}],
+                                "content": [{"text":message.get('content')}]
                             }
                         }
-                    ],
+                    ]
                 }
                 bedrock_messages.append(bedrock_message)
             else:
@@ -134,27 +119,26 @@ class ChatCompletions:
     def _convert_bedrock_response_to_openai_format(self, bedrock_response):
         # Convert Bedrock response format to OpenAI format
         content = ""
-        if bedrock_response.get("output", {}).get("message", {}).get("content"):
-            content_array = bedrock_response["output"]["message"]["content"]
-            content = "".join(item.get("text", "") for item in content_array)
-        if content == "":
-            content = "."
+        if bedrock_response.get('output', {}).get('message', {}).get('content'):
+            content_array = bedrock_response['output']['message']['content']
+            content = "".join(item.get('text', '') for item in content_array)
+        if content == "": content = "."
 
         # Handle tool calls in response
         openai_tool_calls = []
-        if bedrock_response.get("output", {}).get("message", {}).get("content"):
-            for content_item in bedrock_response["output"]["message"]["content"]:
-                if content_item.get("toolUse"):
-                    bedrock_tool_use = content_item["toolUse"]
+        if bedrock_response.get('output', {}).get('message', {}).get('content'):
+            for content_item in bedrock_response['output']['message']['content']:
+                if content_item.get('toolUse'):
+                    bedrock_tool_use = content_item['toolUse']
                     global CURRENT_TOOLUSE_ID
-                    CURRENT_TOOLUSE_ID = bedrock_tool_use["toolUseId"]
+                    CURRENT_TOOLUSE_ID = bedrock_tool_use['toolUseId']
                     openai_tool_call = {
-                        "id": CURRENT_TOOLUSE_ID,
-                        "type": "function",
-                        "function": {
-                            "name": bedrock_tool_use["name"],
-                            "arguments": json.dumps(bedrock_tool_use["input"]),
-                        },
+                        'id': CURRENT_TOOLUSE_ID,
+                        'type': 'function',
+                        'function': {
+                            'name': bedrock_tool_use['name'],
+                            'arguments': json.dumps(bedrock_tool_use['input'])
+                        }
                     }
                     openai_tool_calls.append(openai_tool_call)
 
@@ -166,169 +150,126 @@ class ChatCompletions:
             "system_fingerprint": None,
             "choices": [
                 {
-                    "finish_reason": bedrock_response.get("stopReason", "end_turn"),
+                    "finish_reason": bedrock_response.get('stopReason', 'end_turn'),
                     "index": 0,
                     "message": {
                         "content": content,
-                        "role": bedrock_response.get("output", {})
-                        .get("message", {})
-                        .get("role", "assistant"),
-                        "tool_calls": openai_tool_calls
-                        if openai_tool_calls != []
-                        else None,
-                        "function_call": None,
-                    },
+                        "role": bedrock_response.get('output', {}).get('message', {}).get('role', 'assistant'),
+                        "tool_calls": openai_tool_calls if openai_tool_calls != [] else None,
+                        "function_call": None
+                    }
                 }
             ],
             "usage": {
-                "completion_tokens": bedrock_response.get("usage", {}).get(
-                    "outputTokens", 0
-                ),
-                "prompt_tokens": bedrock_response.get("usage", {}).get(
-                    "inputTokens", 0
-                ),
-                "total_tokens": bedrock_response.get("usage", {}).get("totalTokens", 0),
-            },
+                "completion_tokens": bedrock_response.get('usage', {}).get('outputTokens', 0),
+                "prompt_tokens": bedrock_response.get('usage', {}).get('inputTokens', 0),
+                "total_tokens": bedrock_response.get('usage', {}).get('totalTokens', 0)
+            }
         }
         return OpenAIResponse(openai_format)
 
     async def _invoke_bedrock(
-        self,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: int,
-        temperature: float,
-        tools: Optional[List[dict]] = None,
-        tool_choice: Literal["none", "auto", "required"] = "auto",
-        **kwargs,
-    ) -> OpenAIResponse:
+            self,
+            model: str,
+            messages: List[Dict[str, str]],
+            max_tokens: int,
+            temperature: float,
+            tools: Optional[List[dict]] = None,
+            tool_choice: Literal["none", "auto", "required"] = "auto",
+            **kwargs
+        ) -> OpenAIResponse:
         # Non-streaming invocation of Bedrock model
-        (
-            system_prompt,
-            bedrock_messages,
-        ) = self._convert_openai_messages_to_bedrock_format(messages)
+        system_prompt, bedrock_messages = self._convert_openai_messages_to_bedrock_format(messages)
         response = self.client.converse(
-            modelId=model,
-            system=system_prompt,
-            messages=bedrock_messages,
-            inferenceConfig={"temperature": temperature, "maxTokens": max_tokens},
-            toolConfig={"tools": tools} if tools else None,
+            modelId = model,
+            system = system_prompt,
+            messages = bedrock_messages,
+            inferenceConfig = {"temperature": temperature, "maxTokens": max_tokens},
+            toolConfig = {"tools": tools} if tools else None,
         )
         openai_response = self._convert_bedrock_response_to_openai_format(response)
         return openai_response
 
     async def _invoke_bedrock_stream(
-        self,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: int,
-        temperature: float,
-        tools: Optional[List[dict]] = None,
-        tool_choice: Literal["none", "auto", "required"] = "auto",
-        **kwargs,
-    ) -> OpenAIResponse:
+            self,
+            model: str,
+            messages: List[Dict[str, str]],
+            max_tokens: int,
+            temperature: float,
+            tools: Optional[List[dict]] = None,
+            tool_choice: Literal["none", "auto", "required"] = "auto",
+            **kwargs
+        ) -> OpenAIResponse:
         # Streaming invocation of Bedrock model
-        (
-            system_prompt,
-            bedrock_messages,
-        ) = self._convert_openai_messages_to_bedrock_format(messages)
+        system_prompt, bedrock_messages = self._convert_openai_messages_to_bedrock_format(messages)
         response = self.client.converse_stream(
-            modelId=model,
-            system=system_prompt,
-            messages=bedrock_messages,
-            inferenceConfig={"temperature": temperature, "maxTokens": max_tokens},
-            toolConfig={"tools": tools} if tools else None,
+            modelId = model,
+            system = system_prompt,
+            messages = bedrock_messages,
+            inferenceConfig = {"temperature": temperature, "maxTokens": max_tokens},
+            toolConfig = {"tools": tools} if tools else None,
         )
 
         # Initialize response structure
         bedrock_response = {
-            "output": {"message": {"role": "", "content": []}},
-            "stopReason": "",
-            "usage": {},
-            "metrics": {},
+            'output': {
+                'message': {
+                    'role': '',
+                    'content': []
+                }
+            },
+            'stopReason': '',
+            'usage': {},
+            'metrics': {}
         }
         bedrock_response_text = ""
         bedrock_response_tool_input = ""
 
         # Process streaming response
-        stream = response.get("stream")
+        stream = response.get('stream')
         if stream:
             for event in stream:
-                if event.get("messageStart", {}).get("role"):
-                    bedrock_response["output"]["message"]["role"] = event[
-                        "messageStart"
-                    ]["role"]
-                if event.get("contentBlockDelta", {}).get("delta", {}).get("text"):
-                    bedrock_response_text += event["contentBlockDelta"]["delta"]["text"]
-                    print(
-                        event["contentBlockDelta"]["delta"]["text"], end="", flush=True
-                    )
-                if event.get("contentBlockStop", {}).get("contentBlockIndex") == 0:
-                    bedrock_response["output"]["message"]["content"].append(
-                        {"text": bedrock_response_text}
-                    )
-                if event.get("contentBlockStart", {}).get("start", {}).get("toolUse"):
-                    bedrock_tool_use = event["contentBlockStart"]["start"]["toolUse"]
+                if event.get('messageStart', {}).get('role'):
+                    bedrock_response['output']['message']['role'] = event['messageStart']['role']
+                if event.get('contentBlockDelta', {}).get('delta', {}).get('text'):
+                    bedrock_response_text += event['contentBlockDelta']['delta']['text']
+                    print(event['contentBlockDelta']['delta']['text'], end='', flush=True)
+                if event.get('contentBlockStop', {}).get('contentBlockIndex') == 0:
+                    bedrock_response['output']['message']['content'].append({"text": bedrock_response_text})
+                if event.get('contentBlockStart', {}).get('start', {}).get('toolUse'):
+                    bedrock_tool_use = event['contentBlockStart']['start']['toolUse']
                     tool_use = {
-                        "toolUseId": bedrock_tool_use["toolUseId"],
-                        "name": bedrock_tool_use["name"],
+                        "toolUseId": bedrock_tool_use['toolUseId'],
+                        "name": bedrock_tool_use['name'],
                     }
-                    bedrock_response["output"]["message"]["content"].append(
-                        {"toolUse": tool_use}
-                    )
+                    bedrock_response['output']['message']['content'].append({"toolUse": tool_use})
                     global CURRENT_TOOLUSE_ID
-                    CURRENT_TOOLUSE_ID = bedrock_tool_use["toolUseId"]
-                if event.get("contentBlockDelta", {}).get("delta", {}).get("toolUse"):
-                    bedrock_response_tool_input += event["contentBlockDelta"]["delta"][
-                        "toolUse"
-                    ]["input"]
-                    print(
-                        event["contentBlockDelta"]["delta"]["toolUse"]["input"],
-                        end="",
-                        flush=True,
-                    )
-                if event.get("contentBlockStop", {}).get("contentBlockIndex") == 1:
-                    bedrock_response["output"]["message"]["content"][1]["toolUse"][
-                        "input"
-                    ] = json.loads(bedrock_response_tool_input)
+                    CURRENT_TOOLUSE_ID = bedrock_tool_use['toolUseId']
+                if event.get('contentBlockDelta', {}).get('delta', {}).get('toolUse'):
+                    bedrock_response_tool_input += event['contentBlockDelta']['delta']['toolUse']['input']
+                    print(event['contentBlockDelta']['delta']['toolUse']['input'], end='', flush=True)
+                if event.get('contentBlockStop', {}).get('contentBlockIndex') == 1:
+                    bedrock_response['output']['message']['content'][1]['toolUse']['input'] = json.loads(bedrock_response_tool_input)
         print()
-        openai_response = self._convert_bedrock_response_to_openai_format(
-            bedrock_response
-        )
+        openai_response = self._convert_bedrock_response_to_openai_format(bedrock_response)
         return openai_response
 
     def create(
-        self,
-        model: str,
-        messages: List[Dict[str, str]],
-        max_tokens: int,
-        temperature: float,
-        stream: Optional[bool] = True,
-        tools: Optional[List[dict]] = None,
-        tool_choice: Literal["none", "auto", "required"] = "auto",
-        **kwargs,
-    ) -> OpenAIResponse:
+            self,
+            model: str,
+            messages: List[Dict[str, str]],
+            max_tokens: int,
+            temperature: float,
+            stream: Optional[bool] = True,
+            tools: Optional[List[dict]] = None,
+            tool_choice: Literal["none", "auto", "required"] = "auto",
+            **kwargs
+        ) -> OpenAIResponse:
         # Main entry point for chat completion
         bedrock_tools = []
         if tools is not None:
             bedrock_tools = self._convert_openai_tools_to_bedrock_format(tools)
         if stream:
-            return self._invoke_bedrock_stream(
-                model,
-                messages,
-                max_tokens,
-                temperature,
-                bedrock_tools,
-                tool_choice,
-                **kwargs,
-            )
+            return self._invoke_bedrock_stream(model, messages, max_tokens, temperature, bedrock_tools, tool_choice, **kwargs)
         else:
-            return self._invoke_bedrock(
-                model,
-                messages,
-                max_tokens,
-                temperature,
-                bedrock_tools,
-                tool_choice,
-                **kwargs,
-            )
+            return self._invoke_bedrock(model, messages, max_tokens, temperature, bedrock_tools, tool_choice, **kwargs)

app/config.py

@@ -37,18 +37,6 @@ class ProxySettings(BaseModel):
 
 class SearchSettings(BaseModel):
     engine: str = Field(default="Google", description="Search engine the llm to use")
-    fallback_engines: List[str] = Field(
-        default_factory=lambda: ["DuckDuckGo", "Baidu"],
-        description="Fallback search engines to try if the primary engine fails",
-    )
-    retry_delay: int = Field(
-        default=60,
-        description="Seconds to wait before retrying all engines again after they all fail",
-    )
-    max_retries: int = Field(
-        default=3,
-        description="Maximum number of times to retry all engines when all fail",
-    )
 
 
 class BrowserSettings(BaseModel):

app/llm.py

@@ -18,7 +18,6 @@ from tenacity import (
     wait_random_exponential,
 )
 
-from app.bedrock import BedrockClient
 from app.config import LLMSettings, config
 from app.exceptions import TokenLimitExceeded
 from app.logger import logger  # Assuming a logger is set up in your app
@@ -29,6 +28,7 @@ from app.schema import (
     Message,
     ToolChoice,
 )
+from app.bedrock import BedrockClient
 
 
 REASONING_MODELS = ["o1", "o3-mini"]

app/mcp/server.py

@@ -1,19 +1,30 @@
-import logging
-import sys
-
-
-logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler(sys.stderr)])
-
 import argparse
 import asyncio
 import atexit
 import json
+import logging
+import os
+import sys
 from inspect import Parameter, Signature
 from typing import Any, Dict, Optional
 
 from mcp.server.fastmcp import FastMCP
 
-from app.logger import logger
+
+# Add directories to Python path (needed for proper importing)
+current_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.dirname(current_dir)
+root_dir = os.path.dirname(parent_dir)
+sys.path.insert(0, parent_dir)
+sys.path.insert(0, current_dir)
+sys.path.insert(0, root_dir)
+
+# Configure logging (using the same format as original)
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("mcp-server")
+
 from app.tool.base import BaseTool
 from app.tool.bash import Bash
 from app.tool.browser_use_tool import BrowserUseTool
@@ -34,6 +45,11 @@ class MCPServer:
         self.tools["editor"] = StrReplaceEditor()
         self.tools["terminate"] = Terminate()
 
+        from app.logger import logger as app_logger
+
+        global logger
+        logger = app_logger
+
     def register_tool(self, tool: BaseTool, method_name: Optional[str] = None) -> None:
         """Register a tool with parameter validation and documentation."""
         tool_name = method_name or tool.name

app/tool/web_search.py

@@ -4,7 +4,6 @@ from typing import List
 from tenacity import retry, stop_after_attempt, wait_exponential
 
 from app.config import config
-from app.logger import logger
 from app.tool.base import BaseTool
 from app.tool.search import (
     BaiduSearchEngine,
@@ -45,8 +44,6 @@ class WebSearch(BaseTool):
     async def execute(self, query: str, num_results: int = 10) -> List[str]:
         """
         Execute a Web search and return a list of URLs.
-        Tries engines in order based on configuration, falling back if an engine fails with errors.
-        If all engines fail, it will wait and retry up to the configured number of times.
 
         Args:
             query (str): The search query to submit to the search engine.
@@ -55,109 +52,37 @@ class WebSearch(BaseTool):
         Returns:
             List[str]: A list of URLs matching the search query.
         """
-        # Get retry settings from config
-        retry_delay = 60  # Default to 60 seconds
-        max_retries = 3  # Default to 3 retries
-
-        if config.search_config:
-            retry_delay = getattr(config.search_config, "retry_delay", 60)
-            max_retries = getattr(config.search_config, "max_retries", 3)
-
-        # Try searching with retries when all engines fail
-        for retry_count in range(
-            max_retries + 1
-        ):  # +1 because first try is not a retry
-            links = await self._try_all_engines(query, num_results)
-            if links:
-                return links
-
-            if retry_count < max_retries:
-                # All engines failed, wait and retry
-                logger.warning(
-                    f"All search engines failed. Waiting {retry_delay} seconds before retry {retry_count + 1}/{max_retries}..."
-                )
-                await asyncio.sleep(retry_delay)
-            else:
-                logger.error(
-                    f"All search engines failed after {max_retries} retries. Giving up."
-                )
-
-        return []
-
-    async def _try_all_engines(self, query: str, num_results: int) -> List[str]:
-        """
-        Try all search engines in the configured order.
-
-        Args:
-            query (str): The search query to submit to the search engine.
-            num_results (int): The number of search results to return.
-
-        Returns:
-            List[str]: A list of URLs matching the search query, or empty list if all engines fail.
-        """
         engine_order = self._get_engine_order()
-        failed_engines = []
-
         for engine_name in engine_order:
             engine = self._search_engine[engine_name]
             try:
-                logger.info(f"🔎 Attempting search with {engine_name.capitalize()}...")
                 links = await self._perform_search_with_engine(
                     engine, query, num_results
                 )
                 if links:
-                    if failed_engines:
-                        logger.info(
-                            f"Search successful with {engine_name.capitalize()} after trying: {', '.join(failed_engines)}"
-                        )
                     return links
             except Exception as e:
-                failed_engines.append(engine_name.capitalize())
-                is_rate_limit = "429" in str(e) or "Too Many Requests" in str(e)
-
-                if is_rate_limit:
-                    logger.warning(
-                        f"⚠️ {engine_name.capitalize()} search engine rate limit exceeded, trying next engine..."
-                    )
-                else:
-                    logger.warning(
-                        f"⚠️ {engine_name.capitalize()} search failed with error: {e}"
-                    )
-
-        if failed_engines:
-            logger.error(f"All search engines failed: {', '.join(failed_engines)}")
+                print(f"Search engine '{engine_name}' failed with error: {e}")
         return []
 
     def _get_engine_order(self) -> List[str]:
         """
         Determines the order in which to try search engines.
-        Preferred engine is first (based on configuration), followed by fallback engines,
-        and then the remaining engines.
+        Preferred engine is first (based on configuration), followed by the remaining engines.
 
         Returns:
             List[str]: Ordered list of search engine names.
         """
         preferred = "google"
-        fallbacks = []
-
-        if config.search_config:
-            if config.search_config.engine:
-                preferred = config.search_config.engine.lower()
-            if config.search_config.fallback_engines:
-                fallbacks = [
-                    engine.lower() for engine in config.search_config.fallback_engines
-                ]
+        if config.search_config and config.search_config.engine:
+            preferred = config.search_config.engine.lower()
 
         engine_order = []
-        # Add preferred engine first
         if preferred in self._search_engine:
             engine_order.append(preferred)
-
-        # Add configured fallback engines in order
-        for fallback in fallbacks:
-            if fallback in self._search_engine and fallback not in engine_order:
-                engine_order.append(fallback)
-
+        for key in self._search_engine:
+            if key not in engine_order:
+                engine_order.append(key)
         return engine_order
 
     @retry(

config/config.example.toml

@@ -73,13 +73,6 @@ temperature = 0.0                           # Controls randomness for vision mod
 # [search]
 # Search engine for agent to use. Default is "Google", can be set to "Baidu" or "DuckDuckGo".
 #engine = "Google"
-# Fallback engine order. Default is ["DuckDuckGo", "Baidu"] - will try in this order after primary engine fails.
-#fallback_engines = ["DuckDuckGo", "Baidu"]
-# Seconds to wait before retrying all engines again when they all fail due to rate limits. Default is 60.
-#retry_delay = 60
-# Maximum number of times to retry all engines when all fail. Default is 3.
-#max_retries = 3
-
 
 ## Sandbox configuration
 #[sandbox]

run_mcp.py

@@ -13,14 +13,10 @@ class MCPRunner:
 
     def __init__(self):
         self.root_path = config.root_path
-        self.server_reference = "app.mcp.server"
+        self.server_script = self.root_path / "app" / "mcp" / "server.py"
         self.agent = MCPAgent()
 
-    async def initialize(
-        self,
-        connection_type: str,
-        server_url: str | None = None,
-    ) -> None:
+    async def initialize(self, connection_type: str, server_url: str = None) -> None:
         """Initialize the MCP agent with the appropriate connection."""
         logger.info(f"Initializing MCPAgent with {connection_type} connection...")
 
@@ -28,7 +24,7 @@ class MCPRunner:
             await self.agent.initialize(
                 connection_type="stdio",
                 command=sys.executable,
-                args=["-m", self.server_reference],
+                args=[str(self.server_script)],
             )
         else:  # sse
             await self.agent.initialize(connection_type="sse", server_url=server_url)
@@ -51,14 +47,9 @@ class MCPRunner:
 
     async def run_default(self) -> None:
         """Run the agent in default mode."""
-        prompt = input("Enter your prompt: ")
-        if not prompt.strip():
-            logger.warning("Empty prompt provided.")
-            return
-
-        logger.warning("Processing your request...")
-        await self.agent.run(prompt)
-        logger.info("Request processing completed.")
+        await self.agent.run(
+            "Hello, what tools are available to me? Terminate after you have listed the tools."
+        )
 
     async def cleanup(self) -> None:
         """Clean up agent resources."""

run_mcp_server.py

@@ -1,11 +0,0 @@
-# coding: utf-8
-# A shortcut to launch OpenManus MCP server, where its introduction also solves other import issues.
-from app.mcp.server import MCPServer, parse_args
-
-
-if __name__ == "__main__":
-    args = parse_args()
-
-    # Create and run server (maintaining original flow)
-    server = MCPServer()
-    server.run(transport=args.transport)