DescribeAccountAttributes

Instructions

Implementation Reference

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:100-135 (handler)

  Generic handler function that executes the Alibaba Cloud API call for 'DescribeAccountAttributes' and similar dynamically generated tools. It fetches API metadata, prepares the request, and calls the OpenAPI client.

  def _tools_api_call(service: str, api: str, parameters: dict, ctx: Context):
      service = service.lower()
      api_meta, _ = ApiMetaClient.get_api_meta(service, api)
      version = ApiMetaClient.get_service_version(service)
      method = 'POST' if api_meta.get('methods', [])[0] == 'post' else 'GET'
      path = api_meta.get('path', '/')
      style = ApiMetaClient.get_service_style(service)
      
      # Handling special parameter formats
      processed_parameters = parameters.copy()
      processed_parameters = {k: v for k, v in processed_parameters.items() if v is not None}
      if service == 'ecs':
          for param_name, param_value in parameters.items():
              if param_name in ECS_LIST_PARAMETERS and isinstance(param_value, list):
                  processed_parameters[param_name] = json.dumps(param_value)
      
      req = open_api_models.OpenApiRequest(
          query=OpenApiUtilClient.query(processed_parameters)
      )
      params = open_api_models.Params(
          action=api,
          version=version,
          protocol='HTTPS',
          pathname=path,
          method=method,
          auth_type='AK',
          style=style,
          req_body_type='formData',
          body_type='json'
      )
      logger.info(f'Call API Request: Service: {service} API: {api} Method: {method} Parameters: {processed_parameters}')
      client = create_client(service, processed_parameters.get('RegionId', 'cn-hangzhou'))
      runtime = util_models.RuntimeOptions()
      resp = client.call_api(params, req, runtime)
      logger.info(f'Call API Response: {resp}')
      return resp

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:142-202 (schema)

  Dynamically generates the input schema for the 'DescribeAccountAttributes' tool based on API metadata from Alibaba Cloud.

  def _create_function_schemas(service, api, api_meta):
      schemas = {}
      schemas[api] = {}
      parameters = api_meta.get('parameters', [])
  
      required_params = []
      optional_params = []
  
      for parameter in parameters:
          name = parameter.get('name')
          # TODO 目前忽略了带'.'的参数
          if '.' in name:
              continue
          schema = parameter.get('schema', '')
          required = schema.get('required', False)
  
          if required:
              required_params.append(parameter)
          else:
              optional_params.append(parameter)
  
      def process_parameter(parameter):
          name = parameter.get('name')
          schema = parameter.get('schema', '')
          description = schema.get('description', '')
          example = schema.get('example', '')
          type_ = schema.get('type', '')
          description = f'{description} 参数类型: {type_},参数示例：{example}'
          required = schema.get('required', False)
  
          if service.lower() == 'ecs' and name in ECS_LIST_PARAMETERS and type_ == 'string':
              python_type = list
          else:
              python_type = type_map.get(type_, str)
  
          field_info = (
              python_type,
              field(
                  default=None,
                  metadata={'description': description, 'required': required}
              )
          )
          return name, field_info
  
      for parameter in required_params:
          name, field_info = process_parameter(parameter)
          schemas[api][name] = field_info
  
      for parameter in optional_params:
          name, field_info = process_parameter(parameter)
          schemas[api][name] = field_info
  
      if 'RegionId' not in schemas[api]:
          schemas[api]['RegionId'] = (
              str,
              field(
                  default='cn-hangzhou',
                  metadata={'description': '地域ID', 'required': False}
              )
          )
      return schemas

• src/alibaba_cloud_ops_mcp_server/config.py:7-25 (registration)

  Configuration listing 'DescribeAccountAttributes' as an available ECS tool, which triggers its dynamic registration.

  config = {
      'ecs': [
          'DescribeInstances',
          'DescribeRegions',
          'DescribeZones',
          'DescribeAccountAttributes',
          'DescribeAvailableResource',
          'DescribeImages',
          'DescribeSecurityGroups',
          'DeleteInstances'
      ],
      'Vpc': [
          'DescribeVpcs',
          'DescribeVSwitches'
      ],
      'rds': [
          'DescribeDBInstances'
      ]
  }

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:256-266 (registration)

  Dynamically creates and registers the tool named 'ECS_DescribeAccountAttributes' using FastMCP tool decorator.

  def _create_and_decorate_tool(mcp: FastMCP, service: str, api: str):
      """Create a tool function for an AlibabaCloud openapi."""
      api_meta, _ = ApiMetaClient.get_api_meta(service, api)
      fields = _create_function_schemas(service, api, api_meta).get(api, {})
      description = api_meta.get('summary', '')
      dynamic_lambda = _create_tool_function_with_signature(service, api, fields, description)
      function_name = f'{service.upper()}_{api}'
      decorated_function = mcp.tool(name=function_name)(dynamic_lambda)
  
      return decorated_function

• src/alibaba_cloud_ops_mcp_server/server.py:88-88 (registration)

  Invokes the creation and registration of all tools listed in config, including 'DescribeAccountAttributes' for ECS.

  api_tools.create_api_tools(mcp, config)