futu-stock-mcp-server 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

futu_stock_mcp_server/server.py

@@ -1,16 +1,93 @@
+import os
+import sys
+import warnings
+import logging
+import argparse
+
+# CRITICAL: Check if this is a help command before setting MCP mode
+_is_help_command = any(arg in ['--help', '-h', '--version', '-v'] for arg in sys.argv)
+
+# CRITICAL: Set MCP mode BEFORE any logging to ensure clean stdout
+# But not if this is a help command - in that case, we want normal stdout
+if not _is_help_command:
+    os.environ['MCP_MODE'] = os.environ.get('MCP_MODE', '1')
+
+# CRITICAL: Completely disable all potential stdout pollution sources
+# This must be done BEFORE any other imports or operations
+
+# 1. Disable all warnings that might go to stdout/stderr
+warnings.filterwarnings("ignore")
+warnings.simplefilter("ignore")
+
+# 2. Completely disable the standard logging system
+logging.disable(logging.CRITICAL)
+
+# 3. Set environment variables to prevent ANSI escape sequences
+os.environ['NO_COLOR'] = '1'
+os.environ['TERM'] = 'dumb'
+os.environ['FORCE_COLOR'] = '0'
+os.environ['COLORTERM'] = ''
+os.environ['ANSI_COLORS_DISABLED'] = '1'
+os.environ['PYTHONUNBUFFERED'] = '1'
+os.environ['PYTHONIOENCODING'] = 'utf-8'
+
+# 4. Create a custom stdout wrapper to catch any accidental writes
+class StdoutProtector:
+    """Protects stdout from any non-MCP content"""
+    def __init__(self, original_stdout):
+        self.original = original_stdout
+        self.buffer = ""
+
+    def write(self, text):
+        # Only allow JSON-like content or empty strings
+        if not text or text.isspace():
+            self.original.write(text)
+        elif text.strip().startswith(('{', '[', '"')) or text.strip() == '':
+            self.original.write(text)
+        else:
+            # Silently drop non-JSON content
+            pass
+
+    def flush(self):
+        self.original.flush()
+
+    def __getattr__(self, name):
+        return getattr(self.original, name)
+
+# Apply stdout protection in MCP mode VERY EARLY, before any imports
+if os.getenv('MCP_MODE') == '1':
+    sys.stdout = StdoutProtector(sys.stdout)
+
+# 5. Redirect stderr to null in MCP mode to prevent any accidental output
+_stderr_redirected = False
+_stderr_backup = None
+if os.getenv('MCP_MODE') == '1':
+    # Save original stderr for emergency use
+    _stderr_backup = sys.stderr
+    # Redirect stderr to devnull
+    devnull = open(os.devnull, 'w')
+    sys.stderr = devnull
+    _stderr_redirected = True
+
+# Now we can safely import other modules
 from contextlib import asynccontextmanager
 from collections.abc import AsyncIterator
 from typing import Dict, Any, List, Optional
-from futu import OpenQuoteContext, OpenSecTradeContext, TrdMarket, SecurityFirm, RET_OK
+try:
+    from futu import OpenQuoteContext, OpenSecTradeContext, TrdMarket, SecurityFirm, RET_OK
+except ImportError as e:
+    # In MCP mode, we should avoid printing to stdout/stderr
+    # Log to file only
+    logger.error(f"Failed to import futu: {e}")
+    sys.exit(1)
 import json
 import asyncio
 from loguru import logger
-import os
-import sys
 from dotenv import load_dotenv
-from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp import FastMCP, Context
 from mcp.types import TextContent, PromptMessage
 from mcp.server import Server
+from mcp.server.session import ServerSession
 import atexit
 import signal
 import fcntl
@@ -18,45 +95,163 @@ import psutil
 import time
 from datetime import datetime
 
-# Get the project root directory and add it to Python path
-project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-sys.path.insert(0, project_root)
+# Get the user home directory and create logs directory there
+home_dir = os.path.expanduser("~")
+log_dir = os.path.join(home_dir, "logs")
+os.makedirs(log_dir, exist_ok=True)
 
-# Load environment variables from project root
-env_path = os.path.join(project_root, '.env')
-load_dotenv(env_path)
+# CRITICAL: Configure logging to be MCP-compatible
+# According to MCP best practices, we should:
+# 1. Never write to stdout (reserved for MCP JSON communication)
+# 2. Use file logging for debugging
+# 3. Use MCP Context for operational logging when available
+# 4. Suppress third-party library logs that might pollute output
 
-# Configure logging
-logger.remove()  # Remove default handler
+# Completely silence warnings and third-party logs
+warnings.filterwarnings("ignore")
 
-# Get the project root directory
-log_dir = os.path.join(project_root, "logs")
-os.makedirs(log_dir, exist_ok=True)
+# Configure loguru for file-only logging
+logger.remove()  # Remove all default handlers
 
-# Add file handler
-logger.add(
-    os.path.join(log_dir, "futu_server.log"),
-    rotation="500 MB",
-    retention="10 days",
-    level="DEBUG",
-    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}"
-)
-
-# Add console handler - output to stderr to avoid polluting MCP JSON communication
-logger.add(
-    sys.stderr,
-    level="INFO",
-    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}",
-    colorize=False  # Disable colors to avoid ANSI escape sequences
-)
-
-# Suppress other library logs that might interfere with MCP communication
-import logging
-logging.getLogger().setLevel(logging.WARNING)  # Suppress INFO logs from other libraries
-logging.getLogger("mcp").setLevel(logging.WARNING)  # Suppress MCP internal logs
-logging.getLogger("futu").setLevel(logging.WARNING)  # Suppress Futu API logs
+# CRITICAL: In MCP mode, ensure NO stderr output at all
+if os.getenv('MCP_MODE') == '1':
+    # Remove any remaining handlers that might output to stderr
+    logger.remove()
+    # Add only file handler - NO console output
+    logger.add(
+        os.path.join(log_dir, "futu_mcp_server.log"),
+        rotation="500 MB",
+        retention="10 days",
+        level="DEBUG",
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
+        enqueue=True,  # Thread-safe logging
+        backtrace=True,
+        diagnose=True
+    )
+else:
+    # Non-MCP mode: add file handler
+    logger.add(
+        os.path.join(log_dir, "futu_mcp_server.log"),
+        rotation="500 MB",
+        retention="10 days",
+        level="DEBUG",
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
+        enqueue=True,  # Thread-safe logging
+        backtrace=True,
+        diagnose=True
+    )
+
+# Only add stderr logging if explicitly in debug mode and not in MCP mode
+if os.getenv('FUTU_DEBUG_MODE') == '1' and not os.getenv('MCP_MODE') == '1':
+    logger.add(
+        sys.stderr,
+        level="INFO",
+        format="{time:HH:mm:ss} | {level} | {message}",
+        colorize=False,
+        filter=lambda record: record["level"].name in ["INFO", "WARNING", "ERROR", "CRITICAL"]
+    )
+
+# Suppress all third-party library logging to prevent stdout pollution
+logging.disable(logging.CRITICAL)
 
-logger.info(f"Starting server with log directory: {log_dir}")
+# Set up null handlers for problematic loggers
+class NullHandler(logging.Handler):
+    def emit(self, record):
+        pass
+
+null_handler = NullHandler()
+root_logger = logging.getLogger()
+root_logger.addHandler(null_handler)
+root_logger.setLevel(logging.CRITICAL + 1)
+
+# Specifically silence known problematic loggers
+for logger_name in [
+    'mcp', 'fastmcp', 'futu', 'uvicorn', 'asyncio',
+    'websockets', 'aiohttp', 'urllib3', 'requests'
+]:
+    lib_logger = logging.getLogger(logger_name)
+    lib_logger.disabled = True
+    lib_logger.addHandler(null_handler)
+    lib_logger.setLevel(logging.CRITICAL + 1)
+    lib_logger.propagate = False
+
+# Even more aggressive suppression for futu library
+# This is critical because futu library may output logs during connection
+try:
+    # Suppress futu library logging completely
+    futu_logger = logging.getLogger('futu')
+    futu_logger.disabled = True
+    futu_logger.setLevel(logging.CRITICAL + 1)
+    futu_logger.propagate = False
+
+    # Suppress specific futu sub-modules that are known to output logs
+    for sub_logger_name in [
+        'futu', 'futu.common', 'futu.quote', 'futu.trade',
+        'futu.common.constant', 'futu.common.sys_utils',
+        'futu.quote.open_quote_context', 'futu.quote.quote_response_handler',
+        'futu.trade.open_trade_context', 'futu.trade.trade_response_handler',
+        'futu.common.open_context_base', 'futu.common.network_manager'
+    ]:
+        sub_logger = logging.getLogger(sub_logger_name)
+        sub_logger.disabled = True
+        sub_logger.setLevel(logging.CRITICAL + 1)
+        sub_logger.propagate = False
+
+    # Also redirect any direct print statements from futu to a file
+    if os.getenv('MCP_MODE') == '1':
+        # Create a special log file for futu connection logs
+        home_dir = os.path.expanduser("~")
+        log_dir = os.path.join(home_dir, "logs")
+        os.makedirs(log_dir, exist_ok=True)
+
+        futu_conn_log_file = os.path.join(log_dir, "futu_connection.log")
+        futu_conn_log = open(futu_conn_log_file, 'a')
+
+        # This is a last resort to catch any print statements from futu
+        # We'll redirect stderr to this file temporarily during connection
+        # and then restore it to devnull
+except Exception as e:
+    # If we can't set up additional logging, continue anyway
+    pass
+
+# MCP-compatible logging helper functions
+async def log_to_mcp(ctx: Context, level: str, message: str):
+    """Send log message through MCP Context when available"""
+    try:
+        if level.upper() == "DEBUG":
+            await ctx.debug(message)
+        elif level.upper() == "INFO":
+            await ctx.info(message)
+        elif level.upper() == "WARNING":
+            await ctx.warning(message)
+        elif level.upper() == "ERROR":
+            await ctx.error(message)
+        else:
+            await ctx.info(f"[{level}] {message}")
+    except Exception:
+        # Fallback to file logging if MCP context fails
+        logger.log(level.upper(), message)
+
+def safe_log(level: str, message: str, ctx: Context = None):
+    """Safe logging that uses MCP context when available, file logging otherwise"""
+    # Always log to file
+    logger.log(level.upper(), message)
+
+    # Also send to MCP if context is available
+    if ctx and os.getenv('MCP_MODE') == '1' and not _stderr_redirected:
+        try:
+            import asyncio
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                asyncio.create_task(log_to_mcp(ctx, level, message))
+        except Exception:
+            pass  # Ignore MCP logging errors
+
+# Only log to file, never to stdout/stderr in MCP mode
+# These logs will only be written to file, not to stdout/stderr
+
+# Get project root directory
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 # PID file path
 PID_FILE = os.path.join(project_root, '.futu_mcp.pid')
@@ -359,9 +554,103 @@ def init_trade_connection():
         _is_trade_initialized = False
         return False
 
-def init_futu_connection():
-    """Initialize both quote and trade connections"""
-    return init_quote_connection()
+def init_futu_connection() -> bool:
+    """
+    Initialize connection to Futu OpenD.
+    Returns True if successful, False otherwise.
+    """
+    global quote_ctx, trade_ctx, _is_trade_initialized
+
+    try:
+        # Get connection parameters from environment
+        host = os.getenv('FUTU_HOST', '127.0.0.1')
+        port = int(os.getenv('FUTU_PORT', '11111'))
+
+        # Log to file only
+        logger.info(f"Initializing Futu connection to {host}:{port}")
+
+        # Temporarily redirect stderr to capture any futu library output
+        original_stderr = None
+        futu_log_file = None
+        futu_log_fd = None
+
+        if os.getenv('MCP_MODE') == '1' and _stderr_redirected:
+            try:
+                # Create a special log file for futu connection logs
+                home_dir = os.path.expanduser("~")
+                log_dir = os.path.join(home_dir, "logs")
+                os.makedirs(log_dir, exist_ok=True)
+                futu_log_file = os.path.join(log_dir, "futu_connection.log")
+
+                # Save current stderr (should be devnull)
+                original_stderr = sys.stderr
+
+                # Redirect stderr to futu log file temporarily
+                futu_log_fd = open(futu_log_file, 'a')
+                sys.stderr = futu_log_fd
+            except Exception as e:
+                logger.debug(f"Could not redirect stderr for futu connection: {e}")
+
+        try:
+            # Initialize quote context
+            quote_ctx = OpenQuoteContext(host=host, port=port)
+
+            # Initialize trade context if needed
+            if os.getenv('FUTU_ENABLE_TRADING', '0') == '1':
+                # Get trading parameters
+                trade_env = os.getenv('FUTU_TRADE_ENV', 'SIMULATE')
+                security_firm = os.getenv('FUTU_SECURITY_FIRM', 'FUTUSECURITIES')
+                trd_market = os.getenv('FUTU_TRD_MARKET', 'HK')
+
+                # Map environment strings to Futu enums
+                trade_env_enum = {
+                    'REAL': TrdMarket.REAL,
+                    'SIMULATE': TrdMarket.SIMULATE
+                }.get(trade_env, TrdMarket.SIMULATE)
+
+                security_firm_enum = {
+                    'FUTUSECURITIES': SecurityFirm.FUTUSECURITIES,
+                    'FUTUINC': SecurityFirm.FUTUINC
+                }.get(security_firm, SecurityFirm.FUTUSECURITIES)
+
+                trd_market_enum = {
+                    'HK': TrdMarket.HK,
+                    'US': TrdMarket.US,
+                    'CN': TrdMarket.CN,
+                    'HKCC': TrdMarket.HKCC,
+                    'AU': TrdMarket.AU
+                }.get(trd_market, TrdMarket.HK)
+
+                # Initialize trade context
+                trade_ctx = OpenSecTradeContext(
+                    host=host,
+                    port=port,
+                    security_firm=security_firm_enum
+                )
+                _is_trade_initialized = True
+                logger.info("Trade context initialized successfully")
+
+            logger.info("Futu connection initialized successfully")
+            return True
+
+        finally:
+            # Restore stderr redirection
+            if futu_log_fd:
+                try:
+                    futu_log_fd.close()
+                except:
+                    pass
+                # Restore original stderr (should be devnull)
+                if original_stderr:
+                    sys.stderr = original_stderr
+
+    except Exception as e:
+        error_msg = f"Failed to initialize Futu connection: {str(e)}"
+        logger.error(error_msg)
+        # Make sure we restore stderr even in case of errors
+        if _stderr_redirected and _stderr_backup:
+            sys.stderr = _stderr_backup
+        return False
 
 @asynccontextmanager
 async def lifespan(server: Server):
@@ -411,7 +700,7 @@ def handle_return_data(ret: int, data: Any) -> Dict[str, Any]:
 
 # Market Data Tools
 @mcp.tool()
-async def get_stock_quote(symbols: List[str]) -> Dict[str, Any]:
+async def get_stock_quote(symbols: List[str], ctx: Context[ServerSession, None] = None) -> Dict[str, Any]:
     """Get stock quote data for given symbols
     
     Args:
@@ -455,21 +744,32 @@ async def get_stock_quote(symbols: List[str]) -> Dict[str, Any]:
         - Consider actual needs when selecting stocks
         - Handle exceptions properly
     """
-    ret, data = quote_ctx.get_stock_quote(symbols)
-    if ret != RET_OK:
-        return {'error': str(data)}
+    safe_log("info", f"Getting stock quotes for symbols: {symbols}", ctx)
     
-    # Convert DataFrame to dict if necessary
-    if hasattr(data, 'to_dict'):
-        result = {
-            'quote_list': data.to_dict('records')
-        }
-    else:
-        result = {
-            'quote_list': data
-        }
+    try:
+        ret, data = quote_ctx.get_stock_quote(symbols)
+        if ret != RET_OK:
+            error_msg = f"Failed to get stock quote: {str(data)}"
+            safe_log("error", error_msg, ctx)
+            return {'error': error_msg}
     
-    return result
+        # Convert DataFrame to dict if necessary
+        if hasattr(data, 'to_dict'):
+            result = {
+                'quote_list': data.to_dict('records')
+            }
+        else:
+            result = {
+                'quote_list': data
+            }
+
+        safe_log("info", f"Successfully retrieved quotes for {len(symbols)} symbols", ctx)
+        return result
+
+    except Exception as e:
+        error_msg = f"Exception in get_stock_quote: {str(e)}"
+        safe_log("error", error_msg, ctx)
+        return {'error': error_msg}
 
 @mcp.tool()
 async def get_market_snapshot(symbols: List[str]) -> Dict[str, Any]:
@@ -1126,12 +1426,29 @@ async def get_option_butterfly(symbol: str, expiry: str, strike_price: float) ->
 
 # Account Query Tools
 @mcp.tool()
-async def get_account_list() -> Dict[str, Any]:
+async def get_account_list(ctx: Context[ServerSession, None] = None) -> Dict[str, Any]:
     """Get account list"""
+    safe_log("info", "Attempting to get account list", ctx)
+
     if not init_trade_connection():
-        return {'error': 'Failed to initialize trade connection'}
-    ret, data = trade_ctx.get_acc_list()
-    return handle_return_data(ret, data)
+        error_msg = 'Failed to initialize trade connection'
+        safe_log("error", error_msg, ctx)
+        return {'error': error_msg}
+
+    try:
+        ret, data = trade_ctx.get_acc_list()
+        result = handle_return_data(ret, data)
+
+        if 'error' not in result:
+            safe_log("info", "Successfully retrieved account list", ctx)
+        else:
+            safe_log("error", f"Failed to get account list: {result['error']}", ctx)
+
+        return result
+    except Exception as e:
+        error_msg = f"Exception in get_account_list: {str(e)}"
+        safe_log("error", error_msg, ctx)
+        return {'error': error_msg}
 
 @mcp.tool()
 async def get_funds() -> Dict[str, Any]:
@@ -1456,47 +1773,91 @@ async def get_current_time() -> Dict[str, Any]:
 
 def main():
     """Main entry point for the futu-mcp-server command."""
+    # Parse command line arguments first
+    parser = argparse.ArgumentParser(
+        description="Futu Stock MCP Server - A Model Context Protocol server for accessing Futu OpenAPI functionality",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  futu-mcp-server                    # Start the MCP server
+  futu-mcp-server --help            # Show this help message
+
+Environment Variables:
+  FUTU_HOST                         # Futu OpenD host (default: 127.0.0.1)
+  FUTU_PORT                         # Futu OpenD port (default: 11111)
+  FUTU_ENABLE_TRADING               # Enable trading features (default: 0)
+  FUTU_TRADE_ENV                    # Trading environment: SIMULATE or REAL (default: SIMULATE)
+  FUTU_SECURITY_FIRM                # Security firm: FUTUSECURITIES or FUTUINC (default: FUTUSECURITIES)
+  FUTU_TRD_MARKET                   # Trading market: HK or US (default: HK)
+  FUTU_DEBUG_MODE                   # Enable debug logging (default: 0)
+        """
+    )
+    
+    parser.add_argument(
+        '--version', 
+        action='version', 
+        version='futu-stock-mcp-server 0.1.3'
+    )
+    
+    args = parser.parse_args()
+    
     try:
-        # Ensure no color output in MCP mode
+        # CRITICAL: Set MCP mode BEFORE any logging to ensure clean stdout
+        os.environ['MCP_MODE'] = '1'
+
+        # Ensure no color output or ANSI escape sequences in MCP mode
         os.environ['NO_COLOR'] = '1'
         os.environ['TERM'] = 'dumb'
+        os.environ['FORCE_COLOR'] = '0'
+        os.environ['COLORTERM'] = ''
+        os.environ['ANSI_COLORS_DISABLED'] = '1'
+        os.environ['PYTHONUNBUFFERED'] = '1'
+        os.environ['PYTHONIOENCODING'] = 'utf-8'
 
-        # 清理旧的进程和文件
+        # Disable Python buffering to ensure clean MCP JSON communication
+
+        # Clean up stale processes and acquire lock
         cleanup_stale_processes()
-        
-        # 获取锁
+
         lock_fd = acquire_lock()
         if lock_fd is None:
+            # Use file logging only - no stderr output in MCP mode
             logger.error("Failed to acquire lock. Another instance may be running.")
             sys.exit(1)
             
-        # 设置信号处理
+        # Set up signal handlers
         signal.signal(signal.SIGINT, signal_handler)
         signal.signal(signal.SIGTERM, signal_handler)
             
-        logger.info("Initializing Futu connection...")
+        # Initialize Futu connection with file logging only
+        logger.info("Initializing Futu connection for MCP server...")
         if init_futu_connection():
             logger.info("Successfully initialized Futu connection")
-            logger.info("Starting MCP server in stdio mode...")
-            logger.info("Press Ctrl+C to stop the server")
+            logger.info("Starting MCP server in stdio mode - stdout reserved for JSON communication")
+
             try:
+                # Run MCP server - stdout will be used for JSON communication only
                 mcp.run(transport='stdio')
             except KeyboardInterrupt:
-                logger.info("Received keyboard interrupt, shutting down...")
+                logger.info("Received keyboard interrupt, shutting down gracefully...")
                 cleanup_all()
                 os._exit(0)
             except Exception as e:
-                logger.error(f"Error running server: {str(e)}")
+                logger.error(f"Error running MCP server: {str(e)}")
                 cleanup_all()
                 os._exit(1)
         else:
-            logger.error("Failed to initialize Futu connection. Server will not start.")
+            logger.error("Failed to initialize Futu connection. MCP server will not start.")
             os._exit(1)
+
     except Exception as e:
-        logger.error(f"Error starting server: {str(e)}")
+        # In MCP mode, we should avoid printing to stdout
+        # Log to file only
+        logger.error(f"Error starting MCP server: {str(e)}")
         sys.exit(1)
     finally:
         cleanup_all() 
 
 if __name__ == "__main__":
     main()
+

{futu_stock_mcp_server-0.1.2.dist-info → futu_stock_mcp_server-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: futu-stock-mcp-server
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Model Context Protocol (MCP) server for accessing Futu OpenAPI functionality
 Project-URL: Homepage, https://github.com/shuizhengqi1/futu-stock-mcp-server
 Project-URL: Documentation, https://github.com/shuizhengqi1/futu-stock-mcp-server#readme
@@ -40,7 +40,6 @@ Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown
 
-[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/shuizhengqi1-futu-stocp-mcp-server-badge.png)](https://mseep.ai/app/shuizhengqi1-futu-stocp-mcp-server)
 
 # Futu Stock MCP Server
 
@@ -399,13 +398,29 @@ python -m futu_stock_mcp_server.server
 ```
 
 ### 日志调试
-启用详细日志：
+
+本项目已根据 [MCP 官方文档](https://github.com/modelcontextprotocol/python-sdk) 的最佳实践配置了日志系统：
+
+#### MCP 兼容的日志配置
+- **文件日志**: 所有日志写入 `logs/futu_server.log`，自动轮转和清理
+- **MCP Context 日志**: 工具执行期间通过 MCP Context 发送日志给客户端
+- **stdout 保护**: 确保 stdout 仅用于 MCP JSON 通信，避免污染
+
+#### 调试模式（仅开发时使用）
 ```bash
-export LOG_LEVEL=DEBUG
+# 启用调试模式（会向 stderr 输出日志）
+export FUTU_DEBUG_MODE=1
 futu-mcp-server
 ```
 
-日志文件位置：`./logs/futu_server.log`
+**注意**: 在 MCP 客户端中不要启用调试模式，因为它会向 stderr 输出日志。
+
+#### 日志文件位置
+- 主日志文件：`./logs/futu_server.log`
+- 自动轮转：500 MB 后轮转
+- 自动清理：保留 10 天
+
+详细的日志配置说明请参考 [docs/LOGGING.md](docs/LOGGING.md)。
             tools = await session.list_tools()
 
             # Call a tool

futu_stock_mcp_server-0.1.4.dist-info/RECORD

@@ -0,0 +1,7 @@
+futu_stock_mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+futu_stock_mcp_server/server.py,sha256=SokGZ3seYN1KwNozJqpbAmRsjcoYVSJ8v_wvMHu3pcs,66611
+futu_stock_mcp_server-0.1.4.dist-info/METADATA,sha256=V8KxUH0ehGGfS7FtOGMH6t-kk1NYkKHhFLi3Vg84FO4,21041
+futu_stock_mcp_server-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+futu_stock_mcp_server-0.1.4.dist-info/entry_points.txt,sha256=GAdKqPJD9dJ_fRA3e3m0NRia0elN5OcjEeAI30vOcIM,70
+futu_stock_mcp_server-0.1.4.dist-info/licenses/LICENSE,sha256=XQBSQkjjpkymu_uLdyis4oNynV60VH1X7nS16uwM6g0,1069
+futu_stock_mcp_server-0.1.4.dist-info/RECORD,,

futu_stock_mcp_server-0.1.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-futu_stock_mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-futu_stock_mcp_server/server.py,sha256=xFtYbURXhj0DOkbCFgwHDKHCAATWlSxdBZudrWsodVc,52810
-futu_stock_mcp_server-0.1.2.dist-info/METADATA,sha256=CmSaX6UUSExUdbci62zSZER2udDlV6Fqfqd3SSYHSlg,20453
-futu_stock_mcp_server-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-futu_stock_mcp_server-0.1.2.dist-info/entry_points.txt,sha256=GAdKqPJD9dJ_fRA3e3m0NRia0elN5OcjEeAI30vOcIM,70
-futu_stock_mcp_server-0.1.2.dist-info/licenses/LICENSE,sha256=XQBSQkjjpkymu_uLdyis4oNynV60VH1X7nS16uwM6g0,1069
-futu_stock_mcp_server-0.1.2.dist-info/RECORD,,