DescribeAvailableResource

Instructions

Implementation Reference

• src/alibaba_cloud_ops_mcp_server/config.py:8-17 (registration)

  Configuration listing 'DescribeAvailableResource' as one of the ECS tools to be dynamically registered.

  'ecs': [
      'DescribeInstances',
      'DescribeRegions',
      'DescribeZones',
      'DescribeAccountAttributes',
      'DescribeAvailableResource',
      'DescribeImages',
      'DescribeSecurityGroups',
      'DeleteInstances'
  ],

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

  Calls create_api_tools to register all API tools from config, including DescribeAvailableResource.

  api_tools.create_api_tools(mcp, config)

• src/alibaba_cloud_ops_mcp_server/tools/api_tools.py:267-270 (registration)

  Iterates over config to create and register dynamic tools like ECS_DescribeAvailableResource.

  def create_api_tools(mcp: FastMCP, config:dict):
      for service_code, apis in config.items():
          for api_name in apis:
              _create_and_decorate_tool(mcp, service_code, api_name)

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

  Handler function that executes the Alibaba Cloud API call for dynamic tools including DescribeAvailableResource.

  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:138-203 (schema)

  Dynamically creates the input schema for the DescribeAvailableResource tool from API metadata.

  def _create_parameter_schema(fields: dict):
      return make_dataclass("ParameterSchema", [(name, type_, value) for name, (type_, value) in fields.items()])
  
  
  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