binance-futures-mcp 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

{binance_futures_mcp-1.0.7.dist-info → binance_futures_mcp-1.0.9.dist-info}/METADATA

@@ -1,12 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: binance-futures-mcp
-Version: 1.0.7
-Summary: A Model Context Protocol server for Binance Futures API
+Version: 1.0.9
+Summary: A Model Context Protocol server for Binance Futures API with comprehensive trading tools including TP/SL management
 Home-page: https://github.com/alexcandrabersiva/bin-mcp
 Author: Binance MCP Server
-Project-URL: Bug Tracker, https://github.com/alexcandrabersiva/bin-mcp/issues
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/alexcandrabersiva/bin-mcp
 Project-URL: Repository, https://github.com/alexcandrabersiva/bin-mcp.git
-Keywords: mcp binance trading futures api model-context-protocol
+Project-URL: Issues, https://github.com/alexcandrabersiva/bin-mcp/issues
+Keywords: mcp,binance,trading,futures,api,model-context-protocol
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -20,9 +22,18 @@ Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mcp (>=1.0.0)
-Requires-Dist: aiohttp (>=3.8.0)
-Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
 
 # Binance MCP Server
 

binance_futures_mcp-1.0.9.dist-info/RECORD

@@ -0,0 +1,9 @@
+binance_futures_mcp-1.0.9.dist-info/licenses/LICENSE,sha256=zqfwopvOi7kOx5YVOnehgmRFR-IU3x1n9JEShr3QOYg,1075
+binance_mcp/__init__.py,sha256=ExUxc1kp3GoSwmEtC7eGgFMZlvSQ4IdW1T5xhw-NT98,106
+binance_mcp/__main__.py,sha256=_9DBrtv0PAvjLjCqKk_cMfGtkqSUOcmU6HeQKFjuFMQ,214
+binance_mcp/server.py,sha256=NlgfZhT3si4y0UiGxRZE92rAehcWYFGKymMGgkQMKIo,62387
+binance_futures_mcp-1.0.9.dist-info/METADATA,sha256=vdWuCJtPFPqjiEgVBBCNVl-jEWW_cwnCD38Sk2zwDlk,11872
+binance_futures_mcp-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+binance_futures_mcp-1.0.9.dist-info/entry_points.txt,sha256=-1iVs9AF7JQBS-xMichP9hQhbCY7YfLFRJVaNKwuN34,69
+binance_futures_mcp-1.0.9.dist-info/top_level.txt,sha256=RqGhe1caZUvBF_ezvTiLZD8kVS25eiWVkfJfmoND9m8,12
+binance_futures_mcp-1.0.9.dist-info/RECORD,,

{binance_futures_mcp-1.0.7.dist-info → binance_futures_mcp-1.0.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

binance_mcp/server.py

@@ -1,9 +1,11 @@
 #!/usr/bin/env python3
 
 import asyncio
+import argparse
 import hashlib
 import hmac
 import json
+import os
 import time
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
@@ -48,7 +50,7 @@ class BinanceClient:
             timeout=timeout,
             connector=connector,
             headers={
-                'User-Agent': 'binance-mcp-server/1.0.7',
+                'User-Agent': 'binance-mcp-server/1.0.9',
                 'Content-Type': 'application/x-www-form-urlencoded'
             }
         )
@@ -96,15 +98,21 @@ class BinanceClient:
         try:
             if method == "GET":
                 async with self.session.get(url, params=params, headers=headers, ssl=False) as response:
-                    response.raise_for_status()
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP {response.status}: {error_text}")
                     return await response.json()
             elif method == "POST":
                 async with self.session.post(url, data=params, headers=headers, ssl=False) as response:
-                    response.raise_for_status()
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP {response.status}: {error_text}")
                     return await response.json()
             elif method == "DELETE":
                 async with self.session.delete(url, data=params, headers=headers, ssl=False) as response:
-                    response.raise_for_status()
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(f"HTTP {response.status}: {error_text}")
                     return await response.json()
             else:
                 raise ValueError(f"Unsupported HTTP method: {method}")
@@ -244,26 +252,31 @@ class BinanceMCPServer:
                         "properties": {
                             "symbol": {"type": "string", "description": "Trading pair symbol"},
                             "side": {"type": "string", "description": "Order side ('BUY' or 'SELL')"},
-                            "order_type": {"type": "string", "description": "Order type ('MARKET', 'LIMIT', 'STOP', 'STOP_MARKET', 'TRAILING_STOP_MARKET', etc)"},
+                            "type": {"type": "string", "description": "Order type ('MARKET', 'LIMIT', 'STOP', 'STOP_MARKET', 'TRAILING_STOP_MARKET', etc)"},
+                            "order_type": {"type": "string", "description": "Alternative parameter name for 'type' (for backward compatibility)"},
                             "quantity": {"type": "number", "description": "Order quantity"},
                             "price": {"type": "number", "description": "Order price (for LIMIT orders)"},
-                            "stop_price": {"type": "number", "description": "Stop price (for STOP orders)"},
-                            "time_in_force": {"type": "string", "description": "Time in force (GTC, IOC, FOK)"},
-                            "position_side": {"type": "string", "description": "Position side ('BOTH', 'LONG', 'SHORT')"},
-                            "reduce_only": {"type": "string", "description": "Reduce only flag"},
-                            "new_client_order_id": {"type": "string", "description": "Custom order ID"},
-                            "close_position": {"type": "string", "description": "Close position flag"},
-                            "activation_price": {"type": "number", "description": "Activation price (for TRAILING_STOP_MARKET)"},
-                            "callback_rate": {"type": "number", "description": "Callback rate (for TRAILING_STOP_MARKET)"},
-                            "working_type": {"type": "string", "description": "Working type (MARK_PRICE, CONTRACT_PRICE)"},
-                            "price_protect": {"type": "string", "description": "Price protection flag"},
-                            "new_order_resp_type": {"type": "string", "description": "Response type"},
-                            "recv_window": {"type": "integer", "description": "Receive window"},
+                            "stopPrice": {"type": "number", "description": "Stop price (for STOP orders)"},
+                            "timeInForce": {"type": "string", "description": "Time in force (GTC, IOC, FOK)"},
+                            "positionSide": {"type": "string", "description": "Position side ('BOTH', 'LONG', 'SHORT')"},
+                            "reduceOnly": {"type": "string", "description": "Reduce only flag ('true' or 'false')"},
+                            "newClientOrderId": {"type": "string", "description": "Custom order ID"},
+                            "closePosition": {"type": "string", "description": "Close position flag ('true' or 'false')"},
+                            "activationPrice": {"type": "number", "description": "Activation price (for TRAILING_STOP_MARKET)"},
+                            "callbackRate": {"type": "number", "description": "Callback rate (for TRAILING_STOP_MARKET)"},
+                            "workingType": {"type": "string", "description": "Working type (MARK_PRICE, CONTRACT_PRICE)"},
+                            "priceProtect": {"type": "string", "description": "Price protection flag ('TRUE' or 'FALSE')"},
+                            "newOrderRespType": {"type": "string", "description": "Response type ('ACK', 'RESULT')"},
+                            "recvWindow": {"type": "integer", "description": "Receive window"},
                             "timestamp": {"type": "integer", "description": "Timestamp"},
                             "quantity_precision": {"type": "integer", "description": "Quantity precision for validation"},
                             "price_precision": {"type": "integer", "description": "Price precision for validation"}
                         },
-                        "required": ["symbol", "side", "order_type"]
+                        "required": ["symbol", "side"],
+                        "anyOf": [
+                            {"required": ["type"]},
+                            {"required": ["order_type"]}
+                        ]
                     }
                 ),
                 Tool(
@@ -386,6 +399,73 @@ class BinanceMCPServer:
                         "required": ["symbol", "order_id"]
                     }
                 ),
+                Tool(
+                    name="close_position",
+                    description="Close current position for a symbol (market order to close all or part of position)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "position_side": {"type": "string", "description": "Position side to close ('BOTH', 'LONG', 'SHORT'). Default 'BOTH' for One-way mode"},
+                            "quantity": {"type": "number", "description": "Quantity to close (optional, if not provided will close entire position)"},
+                            "close_all": {"type": "boolean", "description": "If true, closes entire position using closePosition=true parameter"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="modify_order",
+                    description="Modify an existing order (price, quantity, etc.)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id": {"type": "integer", "description": "Order ID to modify"},
+                            "side": {"type": "string", "description": "Order side ('BUY' or 'SELL')"},
+                            "quantity": {"type": "number", "description": "New order quantity"},
+                            "price": {"type": "number", "description": "New order price"},
+                            "priceMatch": {"type": "string", "description": "Price match mode (OPPONENT, OPPONENT_5, OPPONENT_10, OPPONENT_20, QUEUE, QUEUE_5, QUEUE_10, QUEUE_20)"}
+                        },
+                        "required": ["symbol", "order_id", "side", "quantity", "price"]
+                    }
+                ),
+                Tool(
+                    name="add_tp_sl_to_position",
+                    description="Add Take Profit and/or Stop Loss orders to existing position",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "position_side": {"type": "string", "description": "Position side ('BOTH', 'LONG', 'SHORT'). Default 'BOTH' for One-way mode"},
+                            "take_profit_price": {"type": "number", "description": "Take profit price (optional)"},
+                            "stop_loss_price": {"type": "number", "description": "Stop loss price (optional)"},
+                            "quantity": {"type": "number", "description": "Quantity for TP/SL orders (optional, defaults to position size)"},
+                            "tp_order_type": {"type": "string", "description": "Take profit order type ('LIMIT', 'TAKE_PROFIT_MARKET'). Default 'TAKE_PROFIT_MARKET'"},
+                            "sl_order_type": {"type": "string", "description": "Stop loss order type ('STOP_MARKET', 'STOP'). Default 'STOP_MARKET'"},
+                            "time_in_force": {"type": "string", "description": "Time in force for LIMIT TP orders (GTC, IOC, FOK). Default 'GTC'"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="place_bracket_order",
+                    description="Place a position with automatic Take Profit and Stop Loss orders",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "side": {"type": "string", "description": "Order side ('BUY' or 'SELL')"},
+                            "quantity": {"type": "number", "description": "Order quantity"},
+                            "entry_price": {"type": "number", "description": "Entry price (for LIMIT entry order, optional for MARKET)"},
+                            "take_profit_price": {"type": "number", "description": "Take profit price"},
+                            "stop_loss_price": {"type": "number", "description": "Stop loss price"},
+                            "entry_order_type": {"type": "string", "description": "Entry order type ('MARKET', 'LIMIT'). Default 'MARKET'"},
+                            "positionSide": {"type": "string", "description": "Position side ('BOTH', 'LONG', 'SHORT')"},
+                            "timeInForce": {"type": "string", "description": "Time in force for LIMIT orders (GTC, IOC, FOK). Default 'GTC'"}
+                        },
+                        "required": ["symbol", "side", "quantity", "take_profit_price", "stop_loss_price"]
+                    }
+                ),
 
                 # Trading Configuration Tools
                 Tool(
@@ -656,10 +736,39 @@ class BinanceMCPServer:
                     
                     # Order Management Tools
                     elif name == "place_order":
+                        # Filter out precision parameters and pass through all other parameters directly
                         params = {k: v for k, v in arguments.items() if v is not None and k not in ["quantity_precision", "price_precision"]}
-                        # Convert order_type to type for API
+                        
+                        # Handle backward compatibility for order_type parameter
                         if "order_type" in params:
                             params["type"] = params.pop("order_type")
+                        
+                        # Check if type parameter is present
+                        if "type" not in params:
+                            raise ValueError("Missing required parameter 'type'. Please specify the order type (e.g., 'MARKET', 'LIMIT', 'STOP', etc.)")
+                        
+                        # Validate mandatory parameters based on order type
+                        order_type = params.get("type")
+                        if order_type == "LIMIT":
+                            required_params = ["timeInForce", "quantity", "price"]
+                            missing = [p for p in required_params if p not in params]
+                            if missing:
+                                raise ValueError(f"LIMIT order missing required parameters: {missing}")
+                        elif order_type == "MARKET":
+                            if "quantity" not in params:
+                                raise ValueError("MARKET order missing required parameter: quantity")
+                        elif order_type in ["STOP", "TAKE_PROFIT"]:
+                            required_params = ["quantity", "price", "stopPrice"]
+                            missing = [p for p in required_params if p not in params]
+                            if missing:
+                                raise ValueError(f"{order_type} order missing required parameters: {missing}")
+                        elif order_type in ["STOP_MARKET", "TAKE_PROFIT_MARKET"]:
+                            if "stopPrice" not in params:
+                                raise ValueError(f"{order_type} order missing required parameter: stopPrice")
+                        elif order_type == "TRAILING_STOP_MARKET":
+                            if "callbackRate" not in params:
+                                raise ValueError("TRAILING_STOP_MARKET order missing required parameter: callbackRate")
+                        
                         result = await client._make_request("POST", "/fapi/v1/order", params, "TRADE")
                     elif name == "place_multiple_orders":
                         # This requires special handling for batch orders
@@ -697,6 +806,230 @@ class BinanceMCPServer:
                     elif name == "query_order":
                         params = {"symbol": arguments["symbol"], "orderId": arguments["order_id"]}
                         result = await client._make_request("GET", "/fapi/v1/order", params, "USER_DATA")
+                    elif name == "close_position":
+                        # Handle position closing
+                        symbol = arguments["symbol"]
+                        position_side = arguments.get("position_side", "BOTH")
+                        quantity = arguments.get("quantity")
+                        close_all = arguments.get("close_all", False)
+                        
+                        # First, get current position to determine the side and quantity to close
+                        position_params = {"symbol": symbol}
+                        positions = await client._make_request("GET", "/fapi/v2/positionRisk", position_params, "USER_DATA")
+                        
+                        # Find the position to close
+                        position_to_close = None
+                        for pos in positions:
+                            if pos["symbol"] == symbol and float(pos["positionAmt"]) != 0:
+                                if position_side == "BOTH" or pos["positionSide"] == position_side:
+                                    position_to_close = pos
+                                    break
+                        
+                        if not position_to_close:
+                            raise ValueError(f"No open position found for {symbol} with position side {position_side}")
+                        
+                        position_amt = float(position_to_close["positionAmt"])
+                        current_position_side = position_to_close["positionSide"]
+                        
+                        # Determine order side (opposite of position)
+                        if position_amt > 0:  # Long position
+                            order_side = "SELL"
+                        else:  # Short position
+                            order_side = "BUY"
+                            position_amt = abs(position_amt)  # Make positive for order quantity
+                        
+                        # Determine quantity to close
+                        if close_all:
+                            # Use closePosition parameter to close entire position
+                            order_params = {
+                                "symbol": symbol,
+                                "side": order_side,
+                                "type": "MARKET",
+                                "closePosition": "true"
+                            }
+                            if current_position_side != "BOTH":
+                                order_params["positionSide"] = current_position_side
+                        else:
+                            # Close specific quantity or entire position
+                            close_quantity = quantity if quantity else position_amt
+                            order_params = {
+                                "symbol": symbol,
+                                "side": order_side,
+                                "type": "MARKET",
+                                "quantity": close_quantity,
+                                "reduceOnly": "true"
+                            }
+                            if current_position_side != "BOTH":
+                                order_params["positionSide"] = current_position_side
+                        
+                        result = await client._make_request("POST", "/fapi/v1/order", order_params, "TRADE")
+                    elif name == "modify_order":
+                        # Modify existing order
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "orderId": arguments["order_id"],
+                            "side": arguments["side"],
+                            "quantity": arguments["quantity"],
+                            "price": arguments["price"]
+                        }
+                        if "priceMatch" in arguments:
+                            params["priceMatch"] = arguments["priceMatch"]
+                        result = await client._make_request("PUT", "/fapi/v1/order", params, "TRADE")
+                    elif name == "add_tp_sl_to_position":
+                        # Add TP/SL to existing position
+                        symbol = arguments["symbol"]
+                        position_side = arguments.get("position_side", "BOTH")
+                        take_profit_price = arguments.get("take_profit_price")
+                        stop_loss_price = arguments.get("stop_loss_price")
+                        quantity = arguments.get("quantity")
+                        tp_order_type = arguments.get("tp_order_type", "TAKE_PROFIT_MARKET")
+                        sl_order_type = arguments.get("sl_order_type", "STOP_MARKET")
+                        time_in_force = arguments.get("time_in_force", "GTC")
+                        
+                        if not take_profit_price and not stop_loss_price:
+                            raise ValueError("At least one of take_profit_price or stop_loss_price must be provided")
+                        
+                        # Get current position to determine side and quantity
+                        position_params = {"symbol": symbol}
+                        positions = await client._make_request("GET", "/fapi/v2/positionRisk", position_params, "USER_DATA")
+                        
+                        position_to_hedge = None
+                        for pos in positions:
+                            if pos["symbol"] == symbol and float(pos["positionAmt"]) != 0:
+                                if position_side == "BOTH" or pos["positionSide"] == position_side:
+                                    position_to_hedge = pos
+                                    break
+                        
+                        if not position_to_hedge:
+                            raise ValueError(f"No open position found for {symbol} with position side {position_side}")
+                        
+                        position_amt = float(position_to_hedge["positionAmt"])
+                        current_position_side = position_to_hedge["positionSide"]
+                        
+                        # Determine order side (opposite of position)
+                        if position_amt > 0:  # Long position
+                            tp_sl_side = "SELL"
+                        else:  # Short position  
+                            tp_sl_side = "BUY"
+                            position_amt = abs(position_amt)
+                        
+                        order_quantity = quantity if quantity else position_amt
+                        results = []
+                        
+                        # Place Take Profit order
+                        if take_profit_price:
+                            tp_params = {
+                                "symbol": symbol,
+                                "side": tp_sl_side,
+                                "type": tp_order_type,
+                                "quantity": order_quantity,
+                                "reduceOnly": "true"
+                            }
+                            
+                            if current_position_side != "BOTH":
+                                tp_params["positionSide"] = current_position_side
+                            
+                            if tp_order_type == "TAKE_PROFIT_MARKET":
+                                tp_params["stopPrice"] = take_profit_price
+                            else:  # LIMIT
+                                tp_params["price"] = take_profit_price
+                                tp_params["timeInForce"] = time_in_force
+                            
+                            tp_result = await client._make_request("POST", "/fapi/v1/order", tp_params, "TRADE")
+                            results.append({"type": "take_profit", "result": tp_result})
+                        
+                        # Place Stop Loss order
+                        if stop_loss_price:
+                            sl_params = {
+                                "symbol": symbol,
+                                "side": tp_sl_side,
+                                "type": sl_order_type,
+                                "quantity": order_quantity,
+                                "reduceOnly": "true"
+                            }
+                            
+                            if current_position_side != "BOTH":
+                                sl_params["positionSide"] = current_position_side
+                            
+                            if sl_order_type == "STOP_MARKET":
+                                sl_params["stopPrice"] = stop_loss_price
+                            else:  # STOP
+                                sl_params["price"] = stop_loss_price
+                                sl_params["stopPrice"] = stop_loss_price
+                                sl_params["timeInForce"] = time_in_force
+                            
+                            sl_result = await client._make_request("POST", "/fapi/v1/order", sl_params, "TRADE")
+                            results.append({"type": "stop_loss", "result": sl_result})
+                        
+                        result = results
+                    elif name == "place_bracket_order":
+                        # Place entry order with TP/SL
+                        symbol = arguments["symbol"]
+                        side = arguments["side"]
+                        quantity = arguments["quantity"]
+                        entry_price = arguments.get("entry_price")
+                        take_profit_price = arguments["take_profit_price"]
+                        stop_loss_price = arguments["stop_loss_price"]
+                        entry_order_type = arguments.get("entry_order_type", "MARKET")
+                        position_side = arguments.get("positionSide", "BOTH")
+                        time_in_force = arguments.get("timeInForce", "GTC")
+                        
+                        results = []
+                        
+                        # Place entry order
+                        entry_params = {
+                            "symbol": symbol,
+                            "side": side,
+                            "type": entry_order_type,
+                            "quantity": quantity
+                        }
+                        
+                        if position_side != "BOTH":
+                            entry_params["positionSide"] = position_side
+                        
+                        if entry_order_type == "LIMIT":
+                            if not entry_price:
+                                raise ValueError("entry_price is required for LIMIT orders")
+                            entry_params["price"] = entry_price
+                            entry_params["timeInForce"] = time_in_force
+                        
+                        entry_result = await client._make_request("POST", "/fapi/v1/order", entry_params, "TRADE")
+                        results.append({"type": "entry", "result": entry_result})
+                        
+                        # Determine TP/SL side (opposite of entry)
+                        tp_sl_side = "SELL" if side == "BUY" else "BUY"
+                        
+                        # Place Take Profit order
+                        tp_params = {
+                            "symbol": symbol,
+                            "side": tp_sl_side,
+                            "type": "TAKE_PROFIT_MARKET",
+                            "quantity": quantity,
+                            "stopPrice": take_profit_price,
+                            "reduceOnly": "true"
+                        }
+                        if position_side != "BOTH":
+                            tp_params["positionSide"] = position_side
+                        
+                        tp_result = await client._make_request("POST", "/fapi/v1/order", tp_params, "TRADE")
+                        results.append({"type": "take_profit", "result": tp_result})
+                        
+                        # Place Stop Loss order
+                        sl_params = {
+                            "symbol": symbol,
+                            "side": tp_sl_side,
+                            "type": "STOP_MARKET",
+                            "quantity": quantity,
+                            "stopPrice": stop_loss_price,
+                            "reduceOnly": "true"
+                        }
+                        if position_side != "BOTH":
+                            sl_params["positionSide"] = position_side
+                        
+                        sl_result = await client._make_request("POST", "/fapi/v1/order", sl_params, "TRADE")
+                        results.append({"type": "stop_loss", "result": sl_result})
+                        
+                        result = results
                     
                     # Trading Configuration Tools
                     elif name == "change_leverage":
@@ -816,7 +1149,7 @@ async def main():
             write_stream, 
             InitializationOptions(
                 server_name="binance-futures-mcp-server",
-                server_version="1.0.7",
+                server_version="1.0.9",
                 capabilities={
                     "tools": {}
                 }

binance_futures_mcp-1.0.7.dist-info/RECORD

@@ -1,9 +0,0 @@
-binance_mcp/__init__.py,sha256=ExUxc1kp3GoSwmEtC7eGgFMZlvSQ4IdW1T5xhw-NT98,106
-binance_mcp/__main__.py,sha256=_9DBrtv0PAvjLjCqKk_cMfGtkqSUOcmU6HeQKFjuFMQ,214
-binance_mcp/server.py,sha256=mBuB1HX6xf5GSviYV5oIPqKz2werdBiibyxTUA-qnpY,41669
-binance_futures_mcp-1.0.7.dist-info/LICENSE,sha256=zqfwopvOi7kOx5YVOnehgmRFR-IU3x1n9JEShr3QOYg,1075
-binance_futures_mcp-1.0.7.dist-info/METADATA,sha256=GgB3I-rPgq5YKmV9Usi-RYvAtpQ9rk7LowADz1-Q5j8,11418
-binance_futures_mcp-1.0.7.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-binance_futures_mcp-1.0.7.dist-info/entry_points.txt,sha256=-1iVs9AF7JQBS-xMichP9hQhbCY7YfLFRJVaNKwuN34,69
-binance_futures_mcp-1.0.7.dist-info/top_level.txt,sha256=RqGhe1caZUvBF_ezvTiLZD8kVS25eiWVkfJfmoND9m8,12
-binance_futures_mcp-1.0.7.dist-info/RECORD,,