Introducing the WordPress Abilities API

wordpress development

The WordPress Abilities API introduces a standardized, secure, and discoverable method for WordPress core, plugins, and themes to expose capabilities. This new API streamlines developer workflows, enhances automation, and unlocks AI integrations, launching with WordPress 6.9.

Following the official announcement of the WordPress Core AI team, a significant project underway is the new Abilities API. The Abilities API is a first-class, cross-context functional API designed to enable other tools and applications to interface with WordPress seamlessly.

This API aims to standardize how WordPress core, plugins, and themes define and expose their capabilities—or "abilities." The initial implementations of the Abilities API are slated for inclusion in WordPress 6.9, providing a foundation for streamlined developer workflows, enhanced automation, and advanced AI integrations.

What Does the Abilities API Offer Developers?

The Abilities API establishes a central registry where WordPress capabilities are recorded in a machine-readable and human-friendly format. This ensures that abilities are not only discoverable by developers but also programmatically accessible to automation tools across various platforms, including AI agents.

Key goals of this project include:

Discoverability: Easily list and inspect all available abilities through a standard interface.
Interoperability: A uniform schema enables disparate components to compose workflows.
Security-first: Implements explicit permission controls for invoking abilities.
Gradual Adoption: Initially available as a Composer package plugin, with plans for a smooth migration into WordPress core.

Consider this a unified directory for all functions WordPress, its plugins, or themes can perform, registered in a universally understandable manner.

To illustrate its practical application, we will integrate Abilities into a plugin called "List All URLs."

A complete copy of the plugin code is available in this GitHub repository.

List All URLs Plugin Overview

This minimalist plugin adds a Tools sub-menu item, leading to an admin page where users can select to list URLs for all Posts, Pages, or Custom Post Types on their WordPress site.

The core functionality for fetching and displaying data is handled by the list_all_urls_generate_url_list() function. This function accepts two arguments and generates the list of URLs for display:

/**
* Generate a list of URLs based on the provided arguments
* Optionally make them clickable links
*
* @param array $arguments Arguments to customize the URL generation.
* @param bool  $makelinks Whether to return clickable links or plain URLs (escaped).
*
* @return array List of generated URLs.
*/
function list_all_urls_generate_url_list( array $arguments = array(), bool $makelinks = false ): array {
   $default_args   = array(
           'post_type'      => 'post',
           'posts_per_page' => - 1,
           'post_status'    => 'publish',
   );
   $args           = wp_parse_args( $arguments, $default_args );
   $posts          = get_posts( $args );

   $links = array();
   foreach ( $posts as $post ) {
      $permalink = get_permalink( $post );
      if ( $makelinks ) {
         $links[] = '<a href="' . esc_url( $permalink ) . '">' . esc_html( $permalink ) . '</a>';
      } else {
         $links[] = esc_html( $permalink );
      }
   }

   return $links;
}

Internally, this function leverages the WordPress get_posts() function to retrieve data, then formats it as either clickable links or plain URLs.

Future quality-of-life improvements could include options to limit results for large sites, filter URLs by category or date range, and export the generated URLs. However, two significant features would be:

REST API Endpoint: A method to access the URL list outside of WordPress, enabling integration with external services.
Block Editor Block: A block allowing users to embed the URL list within any post, page, or template using the Block Editor.

Implementing these features traditionally requires a substantial amount of setup. If you wish to browse the full code for this solution, you can check out the rest-blocks branch of the GitHub repository.

Traditional Implementation: REST API and Block

REST API Route: You would need to register a custom REST API route and an associated GET endpoint using register_rest_route(). This endpoint would fetch posts and require a callback function to retrieve data, which could then call list_all_urls_generate_url_list() without the $makelinks parameter.

add_action( 'rest_api_init', 'list_all_urls_register_rest_route' );

function list_all_urls_register_rest_route (): void {
   register_rest_route(
           'list-all-urls/v1',
           '/urls',
           array(
               'methods' => 'GET',
               'callback' => 'list_all_urls_rest_fetch_all_urls',
               'args' => array(
                       'type' => array(
                               'validate_callback' => function( $param ) {
                                   return is_string( $param );
                               }
                       ),
               ),
           )
   );
}

function list_all_urls_rest_fetch_all_urls( $arguments ){
   if ( isset($arguments['type'] ) ) {
       $post_type = sanitize_text_field( wp_unslash( $arguments['type'] ) );
   } else {
       $post_type = 'any';
   }
   $args = array(
       'post_type'      => $post_type,
   );
   return list_all_urls_generate_url_list( $args );
}

Custom Block: For a custom block, you could scaffold its structure using create-block, then use the custom REST API endpoint and the api-fetch package to retrieve data for the block's Edit component and render it in the editor.

export default function Edit() {
    const [urls, setUrls] = useState([]);

    useEffect(() => {
        apiFetch( { path: '/list-all-urls/v1/urls' } ).then( ( urls ) => {
            setUrls( urls );
        } );
    }, []);

    if ( ! urls ) {
        return (
            <div { ...useBlockProps() }>
                <p>{ __( 'Loading...', 'list-all-urls' ) }</p>
            </div>
        );
    }

    let urlsList = urls.map( ( url ) => {
        return <li><a href={ url }>{ url }</a></li>;
    });

    return (
        <div { ...useBlockProps() }>
            <ul>{ urlsList }</ul>
        </div>
    );
}

It would be practical to make this a dynamic block, calling list_all_urls_generate_url_list() in a render.php file for front-end rendering.

<?php
/**
* Render file for the List All URLs block.
*/
$block_attributes = get_block_wrapper_attributes();
$urls = list_all_urls_generate_url_list( array( 'post_type' => 'any' ), true );
$urlList = '';
foreach ( $urls as $url ) {
   $urlList .= '<li>' .  wp_kses_post( $url ) . '</li>';
}
?>
<div <?php echo $block_attributes; ?>>
   <ul>
       <?php echo $urlList; ?>
   </ul>
</div>

Further enhancements, such as allowing users to select post types or enable clickable links, would necessitate updating the block to support additional attributes. This approach, however, already involves a significant amount of code simply to expose the URL listing functionality via the REST API and Block Editor, alongside maintaining the existing admin page.

This scenario perfectly highlights the utility of a custom Ability. By registering the functionality in one centralized place, it can be accessed and executed wherever needed.

Installing the Abilities API

To begin, ensure you are working with the latest version of the API. Currently, there are three installation methods:

Clone the GitHub repository: Clone the GitHub repository into your wp-content/plugins directory, install dependencies, run build steps, and activate the plugin.
```
$ git clone git@github.com:WordPress/abilities-api.git
$ cd abilities-api
$ composer install
$ npm install
$ npm run build
```
Download from releases: Download the latest version from the releases page of the GitHub repository, then upload and install the plugin zip file.
Require as Composer package: Require the Composer package as a dependency for your plugin or theme.
```
$ cd /wp-content/plugins/list-all-urls
$ composer require wordpress/abilities-api
```

Cloning the GitHub repository is often preferred for testing, as it provides access to the latest code on the trunk branch.

Abilities to the Rescue

A custom Ability can streamline much of the required core functionality. The PHP documentation offers comprehensive guidance on registering and using Abilities in PHP. Let's explore its application for the List All URLs plugin.

For a full code implementation, refer to the abilities branch of the GitHub repository.

Registering an Ability in PHP is achieved using the wp_register_ability() function. This function should always be called within a callback hooked into the wp_abilities_api_init action hook to ensure proper registration.

add_action( 'wp_abilities_api_init', 'list_all_urls_register_abilities' );

/**
 * Register the ability to list all URLs
 *
 * @return void
 */
function list_all_urls_register_abilities() {
    wp_register_ability(
        'list-all-urls/urls',
        array(
            'label' => __( 'Get All URLs', 'list-all-urls' ),
            'description' => __( 'Retrieves a list of URLs from the WordPress site, optionally as clickable anchor links.', 'list-all-urls' ),
            'category' => 'site',
            'input_schema' => array(
                'type' => 'object',
                'properties' => array(
                        'post_type' => array(
                                'type' => 'string',
                                'description' => 'The post type to retrieve URLs from (e.g., post, page, custom post type).',
                            ),
                        'posts_per_page' => array(
                                'type' => 'integer',
                                'description' => 'Number of posts to retrieve. Use -1 to retrieve all posts.',
                        ),
                        'post_status' => array(
                                'type' => 'string',
                                'description' => 'The status of the posts to retrieve (e.g., publish, draft).',
                        ),
                        'makelinks' => array(
                                'type' => 'boolean',
                                'description' => 'Whether to return URLs as clickable anchor links.',
                        ),
                ),
            ),
            'output_schema' => array(
                    'type' => 'object',
                    'properties' => array(
                            'url' => array(
                                    'type' => 'string',
                                    'description' => 'URL or clickable link to the URL'
                            )
                    )
            ),
            'execute_callback' => 'list_all_urls_generate_url_list',
            'permission_callback' => '__return_true',
        )
    );
}

Deeper Dive into Ability Registration

Registering an Ability requires a unique identifier (e.g., list-all-urls/urls) and an array of arguments. While most arguments are optional, the essential ones include:

label: A human-readable name for the Ability.
description: A concise explanation of the Ability's function.
category: The grouping category for the Ability. Custom categories can be registered, but here we use the available site category.
output_schema: Defines the structure of the data returned by the Ability.
execute_callback: The function invoked when the Ability is executed.
permission_callback: A function that determines whether the current user has the necessary permissions to execute the Ability.

The input_schema argument is optional but highly recommended if your Ability requires input parameters. In this example, it's configured to accept the same arguments as list_all_urls_generate_url_list().

These schemas not only inform the Ability about expected input and output data but also enable automatic data validation. For instance, attempting to pass a non-integer value for posts_per_page in the input would automatically trigger a validation error, preventing Ability execution. Notably, the original list_all_urls_generate_url_list() function serves directly as the Ability's execute_callback, requiring no changes.

Obtaining and Using an Ability in PHP

The next step involves updating the internal admin page to fetch and execute the registered Ability. This primarily involves setting up the $input array, retrieving the Ability object, and executing it.

$input = array(
    'post_type'      => $post_type,
    'posts_per_page' => - 1,
    'post_status'    => 'publish',
    'makelinks'      => $makelinks,
);

$urlsAbility = wp_get_ability( 'list-all-urls/urls' );
$urls = $urlsAbility->execute( $input );

This implementation offers significant extensibility. To allow other plugin or theme developers to utilize this functionality, one simply needs to document the ability identifier, its input schema, and its output schema.

Functions are also available to check for all registered abilities (wp_get_abilities()) and to verify the availability of a specific Ability (wp_has_ability()).

During development, these functions can be inspected using the WP-CLI shell command. For example, to check available abilities:

$ wp shell
wp> $abilities = wp_get_abilities();

The information returned for all registered abilities is quite verbose. Below is a sample output illustrating the structure of several core and custom abilities:

=> array(4) {
  ["core/get-site-info"]=>
  object(WP_Ability)#2691 (9) {
    ["name":protected]=>
    string(18) "core/get-site-info"
    ["label":protected]=>
    string(20) "Get Site Information"
    ["description":protected]=>
    string(113) "Returns site information configured in WordPress. By default returns all fields, or optionally a filtered subset."
    ["category":protected]=>
    string(4) "site"
    ["input_schema":protected]=>
    array(4) {
      ["type"]=>
      string(6) "object"
      ["properties"]=>
      array(1) {
        ["fields"]=>
        array(3) {
          ["type"]=>
          string(5) "array"
          ["items"]=>
          array(2) {
            ["type"]=>
            string(6) "string"
            ["enum"]=>
            array(8) {
              [0]=>
              string(4) "name"
              [1]=>
              string(11) "description"
              [2]=>
              string(3) "url"
              [3]=>
              string(5) "wpurl"
              [4]=>
              string(11) "admin_email"
              [5]=>
              string(7) "charset"
              [6]=>
              string(8) "language"
              [7]=>
              string(7) "version"
            }
          }
          ["description"]=>
          string(81) "Optional: Limit response to specific fields. If omitted, all fields are returned."
        }
      }
      ["additionalProperties"]=>
      bool(false)
      ["default"]=>
      array(0) {
      }
    }
    ["output_schema":protected]=>
    array(3) {
      ["type"]=>
      string(6) "object"
      ["properties"]=>
      array(8) {
        ["name"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(15) "The site title."
        }
        ["description"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(17) "The site tagline."
        }
        ["url"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(18) "The site home URL."
        }
        ["wpurl"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(31) "The WordPress installation URL."
        }
        ["admin_email"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(37) "The site administrator email address."
        }
        ["charset"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(28) "The site character encoding."
        }
        ["language"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(30) "The site language locale code."
        }
        ["version"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(22) "The WordPress version."
        }
      }
      ["additionalProperties"]=>
      bool(false)
    }
    ["execute_callback":protected]=>
    object(Closure)#2689 (2) {
      ["static"]=>
      array(1) {
        ["site_info_fields"]=>
        array(8) {
          [0]=>
          string(4) "name"
          [1]=>
          string(11) "description"
          [2]=>
          string(3) "url"
          [3]=>
          string(5) "wpurl"
          [4]=>
          string(11) "admin_email"
          [5]=>
          string(7) "charset"
          [6]=>
          string(8) "language"
          [7]=>
          string(7) "version"
        }
      }
      ["parameter"]=>
      array(1) {
        ["$input"]=>
        string(10) "<optional>"
      }
    }
    ["permission_callback":protected]=>
    object(Closure)#2690 (0) {
    }
    ["meta":protected]=>
    array(2) {
      ["annotations"]=>
      array(3) {
        ["readonly"]=>
        bool(true)
        ["destructive"]=>
        bool(false)
        ["idempotent"]=>
        bool(true)
      }
      ["show_in_rest"]=>
      bool(true)
    }
  }
  ["core/get-user-info"]=>
  object(WP_Ability)#2694 (9) {
    ["name":protected]=>
    string(18) "core/get-user-info"
    ["label":protected]=>
    string(20) "Get User Information"
    ["description":protected]=>
    string(129) "Returns basic profile details for the current authenticated user to support personalization, auditing, and access-aware behavior."
    ["category":protected]=>
    string(4) "user"
    ["input_schema":protected]=>
    array(0) {
    }
    ["output_schema":protected]=>
    array(4) {
      ["type"]=>
      string(6) "object"
      ["required"]=>
      array(6) {
        [0]=>
        string(2) "id"
        [1]=>
        string(12) "display_name"
        [2]=>
        string(13) "user_nicename"
        [3]=>
        string(10) "user_login"
        [4]=>
        string(5) "roles"
        [5]=>
(6) "locale"
      }
      ["properties"]=>
      array(6) {
        ["id"]=>
        array(2) {
          ["type"]=>
          string(7) "integer"
          ["description"]=>
          string(12) "The user ID."
        }
        ["display_name"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(29) "The display name of the user."
        }
        ["user_nicename"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(35) "The URL-friendly name for the user."
        }
        ["user_login"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(32) "The login username for the user."
        }
        ["roles"]=>
        array(3) {
          ["type"]=>
          string(5) "array"
          ["description"]=>
          string(31) "The roles assigned to the user."
          ["items"]=>
          array(1) {
            ["type"]=>
            string(6) "string"
          }
        }
        ["locale"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(46) "The locale string for the user, such as en_US."
        }
      }
      ["additionalProperties"]=>
      bool(false)
    }
    ["execute_callback":protected]=>
    object(Closure)#2692 (0) {
    }
    ["permission_callback":protected]=>
    object(Closure)#2693 (0) {
    }
    ["meta":protected]=>
    array(2) {
      ["annotations"]=>
      array(3) {
        ["readonly"]=>
        bool(true)
        ["destructive"]=>
        bool(false)
        ["idempotent"]=>
        bool(true)
      }
      ["show_in_rest"]=>
      bool(false)
    }
  }
  ["core/get-environment-info"]=>
  object(WP_Ability)#2697 (9) {
    ["name":protected]=>
    string(25) "core/get-environment-info"
    ["label":protected]=>
    string(20) "Get Environment Info"
    ["description":protected]=>
    string(156) "Returns core details about the site's runtime context for diagnostics and compatibility (environment, PHP runtime, database server info, WordPress version)."
    ["category":protected]=>
    string(4) "site"
    ["input_schema":protected]=>
    array(0) {
    }
    ["output_schema":protected]=>
    array(4) {
      ["type"]=>
      string(6) "object"
      ["required"]=>
      array(4) {
        [0]=>
        string(11) "environment"
        [1]=>
        string(11) "php_version"
        [2]=>
        string(14) "db_server_info"
        [3]=>
        string(10) "wp_version"
      }
      ["properties"]=>
      array(4) {
        ["environment"]=>
        array(3) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(109) "The site's runtime environment classification (can be one of these: production, staging, development, local)."
          ["enum"]=>
          array(4) {
            [0]=>
            string(10) "production"
            [1]=>
            string(7) "staging"
            [2]=>
            string(11) "development"
            [3]=>
            string(5) "local"
          }
        }
        ["php_version"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(44) "The PHP runtime version executing WordPress."
        }
        ["db_server_info"]=>
        array(3) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(69) "The database server vendor and version string reported by the driver."
          ["examples"]=>
          array(2) {
            [0]=>
            string(6) "8.0.34"
            [1]=>
            string(15) "10.11.6-MariaDB"
          }
        }
        ["wp_version"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(48) "The WordPress core version running on this site."
        }
      }
      ["additionalProperties"]=>
      bool(false)
    }
    ["execute_callback":protected]=>
    object(Closure)#2695 (0) {
    }
    ["permission_callback":protected]=>
    object(Closure)#2696 (0) {
    }
    ["meta":protected]=>
    array(2) {
      ["annotations"]=>
      array(3) {
        ["readonly"]=>
        bool(true)
        ["destructive"]=>
        bool(false)
        ["idempotent"]=>
        bool(true)
      }
      ["show_in_rest"]=>
      bool(true)
    }
  }
  ["list-all-urls/urls"]=>
  object(WP_Ability)#2698 (9) {
    ["name":protected]=>
    string(18) "list-all-urls/urls"
    ["label":protected]=>
    string(12) "Get All URLs"
    ["description":protected]=>
    string(87) "Retrieves a list of URLs from the WordPress site, optionally as clickable anchor links."
    ["category":protected]=>
    string(13) "list-all-urls"
    ["input_schema":protected]=>
    array(2) {
      ["type"]=>
      string(6) "object"
      ["properties"]=>
      array(4) {
        ["post_type"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(73) "The post type to retrieve URLs from (e.g., post, page, custom post type)."
        }
        ["posts_per_page"]=>
        array(2) {
          ["type"]=>
          string(7) "integer"
          ["description"]=>
          string(58) "Number of posts to retrieve. Use -1 to retrieve all posts."
        }
        ["post_status"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(59) "The status of the posts to retrieve (e.g., publish, draft)."
        }
        ["makelinks"]=>
        array(2) {
          ["type"]=>
          string(7) "boolean"
          ["description"]=>
          string(49) "Whether to return URLs as clickable anchor links."
        }
      }
    }
    ["output_schema":protected]=>
    array(2) {
      ["type"]=>
      string(6) "object"
      ["properties"]=>
      array(1) {
        ["url"]=>
        array(2) {
          ["type"]=>
          string(6) "string"
          ["description"]=>
          string(32) "URL or clickable link to the URL"
        }
      }
    }
    ["execute_callback":protected]=>
    string(31) "list_all_urls_generate_url_list"
    ["permission_callback":protected]=>
    string(13) "__return_true"
    ["meta":protected]=>
    array(2) {
      ["annotations"]=>
      array(3) {
        ["readonly"]=>
        NULL
        ["destructive"]=>
        NULL
        ["idempotent"]=>
        NULL
      }
      ["show_in_rest"]=>
      bool(true)
    }
  }
}

To check if a specific Ability is available:

$ wp shell
wp> $found = wp_has_ability('list-all-urls/urls');
=> bool(true)

Fetching a single Ability returns the complete Ability object, providing details on its function and expected inputs/outputs.

$ wp shell
wp> $ability = wp_get_ability('list-all-urls/urls');
=> object(WP_Ability)#2698 (9) {
  ["name":protected]=>
  string(18) "list-all-urls/urls"
  ["label":protected]=>
  string(12) "Get All URLs"
  ["description":protected]=>
  string(87) "Retrieves a list of URLs from the WordPress site, optionally as clickable anchor links."
  ["category":protected]=>
  string(13) "list-all-urls"
  ["input_schema":protected]=>
  array(2) {
    ["type"]=>
    string(6) "object"
    ["properties"]=>
    array(4) {
      ["post_type"]=>
      array(2) {
        ["type"]=>
        string(6) "string"
        ["description"]=>
        string(73) "The post type to retrieve URLs from (e.g., post, page, custom post type)."
      }
      ["posts_per_page"]=>
      array(2) {
        ["type"]=>
        string(7) "integer"
        ["description"]=>
        string(58) "Number of posts to retrieve. Use -1 to retrieve all posts."
      }
      ["post_status"]=>
      array(2) {
        ["type"]=>
        string(6) "string"
        ["description"]=>
        string(59) "The status of the posts to retrieve (e.g., publish, draft)."
      }
      ["makelinks"]=>
      array(2) {
        ["type"]=>
        string(7) "boolean"
        ["description"]=>
        string(49) "Whether to return URLs as clickable anchor links."
      }
    }
  }
  ["output_schema":protected]=>
  array(2) {
    ["type"]=>
    string(6) "object"
    ["properties"]=>
    array(1) {
      ["url"]=>
      array(2) {
        ["type"]=>
        string(6) "string"
        ["description"]=>
        string(32) "URL or clickable link to the URL"
      }
    }
  }
  ["execute_callback":protected]=>
  string(31) "list_all_urls_generate_url_list"
  ["permission_callback":protected]=>
  string(13) "__return_true"
  ["meta":protected]=>
  array(2) {
    ["annotations"]=>
    array(3) {
      ["readonly"]=>
      NULL
      ["destructive"]=>
      NULL
      ["idempotent"]=>
      NULL
    }
    ["show_in_rest"]=>
    bool(true)
  }
}

Out-of-the-Box REST API Support

One significant advantage of Abilities is their inherent REST API support, configurable similarly to Custom Post Types. By enabling the meta.show_in_rest argument during Ability registration, it automatically supports the Abilities REST API endpoints.

'meta' => array(
       'show_in_rest' => true,
),

The Abilities REST API endpoints are accessible under the /wp-json/wp-abilities/v1 namespace. Access to these endpoints requires an authenticated user and supports all authentication methods compatible with the standard WordPress REST API.

Through this namespace, you can perform default Ability actions, including:

Listing all Abilities: Send a GET request to /wp-json/wp-abilities/v1/abilities.
Retrieving a single Ability: Send a GET request to /wp-json/wp-abilities/v1/{namespace/ability}, where {namespace/ability} is the unique ID of your registered Ability (e.g., list-all-urls/urls).
Executing an Ability: Send either a GET or POST request (depending on the Ability’s readonly setting) to /wp-json/wp-abilities/v1/{namespace/ability}/run.

Crucially, the permission_callback defined during Ability registration is also respected when Abilities are executed via the REST API. This ensures that only authenticated users with the appropriate permissions can execute any given Ability through the REST API. All these capabilities are unlocked simply by enabling a single argument during registration!

Abilities Are Coming to Core!

The server-side (PHP) Abilities registration, retrieval, and execution, including REST API support, was recently approved for merging into WordPress 6.9. By early December, this functionality will be available out-of-the-box in WordPress. You can assist in testing it now by following the instructions in the Help Test WordPress 6.9 post.

Utilizing an Ability in JavaScript

One might wonder if it's still necessary to use methods like fetch-api to retrieve data from REST API endpoints. Fortunately, the Abilities API includes a JavaScript client, offering built-in support for fetching and executing custom Abilities directly in the browser.

Currently, the JavaScript client resides within the GitHub repository, but the ultimate goal is to ship it as a Gutenberg package. This means there's a strong likelihood it will be integrated into WordPress core by version 7.0 (or potentially earlier via the Gutenberg plugin).

If you require the Abilities API as a Composer package, you can start using it in your plugins or themes without any conflicts with the Core Abilities API. The JavaScript client also provides functions to list, fetch, and execute custom Abilities, as well as a function for creating new Abilities in JavaScript. For the List All URLs plugin, only the executeAbility function is needed.

import { executeAbility } from '@wordpress/abilities';

Then, you can execute the Ability by passing it a JSON object for the required input and utilize the returned data within your block.

useEffect(() => {
   executeAbility( 'list-all-urls/urls', { 'makelinks': attributes.makeLinks } ).then( ( urls ) => {
       setUrls( urls );
   } );
}, []);

Further Learning and Engagement

Follow the development of the Abilities API in the official GitHub repository and review its documentation.
Join discussions on the WordPress Slack in the #core-ai channel or monitor the Core AI team blog for updates and news.

The Journey Has Just Begun...

Consider the diverse ways WordPress core, plugins, and themes currently expose their capabilities to developers. WordPress traditionally lacks a standardized method for building and communicating public APIs, leading to a variety of approaches—from action and filter hooks to global functions, REST API endpoints, or extensible objects. The Abilities API addresses this by providing WordPress developers with a standardized, discoverable method to expose common functionalities.

These Abilities can then be accessed and executed consistently across WordPress's application (PHP) and presentation (JavaScript) layers, as well as by external applications (via the REST API). Furthermore, when combined with tools like the WordPress MCP adapter, Abilities can enable AI agents to interact with your site's capabilities, opening up even more possibilities.

The Abilities API represents an exciting new paradigm for WordPress development, promising to unlock new avenues for innovation.