Die in WordPress 6.9 eingeführte Abilities-API schafft eine gemeinsame Sprache, die es allen WordPress-Komponenten – sowohl dem Kern als auch den Plugins – ermöglicht, ihre Funktionen auf einheitliche und verständliche Weise für Menschen und Maschinen gleichermaßen bereitzustellen. Dadurch ist deine WordPress-Seite bereit für die standardisierte und sichere Integration mit externen Automatisierungstools.
Wenn du dich fragst, wie einige Anwendungsfälle für die Abilities-API aussehen könnten, stell dir ein KI-Modell vor, das einen Nutzer durch den Kaufprozess führt und es ihm sogar ermöglicht, den Kauf abzuschließen, ohne deine E-Commerce-Website zu besuchen. Oder stell dir eine CI/CD-Pipeline auf GitHub Actions vor, die aus einer Audio- oder Videodatei extrahierten Text verarbeitet und zur Veröffentlichung an WordPress sendet. Die Anwendungsfälle sind endlos.
Die Abilities-API verändert die Rolle von WordPress innerhalb des Ökosystems grundlegend. Es ist nicht mehr nur ein Blog und auch kein reines CMS mehr; heute fungiert WordPress als verteilte Ausführungs-Engine, die von außen gesteuert werden kann – wie eine Art Betriebssystem, das vollständig für autonome Agenten vorbereitet ist.
Neugierig, mehr zu erfahren? Lass uns tiefer eintauchen.
Wozu dient eine „Ability“?
Eine „Ability“ ist eine auffindbare, umsetzbare Funktion auf einer WordPress-Website, die bestimmte Vorgänge für externe Entitäten (wie KI-Modelle) oder interne Komponenten ermöglicht.
Die API kann beispielsweise für Folgendes genutzt werden:
- Nach Inhalten suchen oder bestimmte Datenbankoperationen ausführen
- Das Auslesen von Website-Konfigurationseinstellungen
- Einen Beitrag erstellen
- Eine JSON-Struktur in Gutenberg-Blöcke umwandeln
Eine Fähigkeit verfügbar zu machen bedeutet, eine bestimmte Funktionalität interoperabel zu gestalten. Bevor eine Fähigkeit erkannt und genutzt werden kann, muss sie in einem zentralen Katalog registriert werden. Erst dann können WordPress und KI-Modelle sie erkennen, ihre Absicht verstehen und bei Bedarf aufrufen.
Standardmäßig ist die Funktionalität deiner Plugins vollständig isoliert. Durch die Registrierung einer Fähigkeit erklärst du, dass die zugrunde liegende Logik als Dienst für das gesamte Ökosystem verfügbar ist.
Schauen wir uns ein Beispiel an. Wenn dein Plugin eine Funktion hat, die ein ursprüngliches JSON-Objekt in strukturierte Inhalte umwandelt, die für Gutenberg-Blöcke bereit sind, kannst du diese als Fähigkeit registrieren. Dadurch können andere Tools mit den erforderlichen Berechtigungen genau dieselbe Funktion auslösen.
In unserem vorherigen Tutorial zum WordPress AI Client übernahm das Plugin die Kernlogik des Versendens einer Audiodatei an das KI-Modell, das eine JSON-strukturierte Antwort zurückgab, um Gutenberg-Blöcke zu generieren. Diese Funktionalität blieb jedoch auf unser Plugin beschränkt. Indem du diesen Prozess als „Fähigkeit“ registrierst, entkoppelst du die Ausführung, und jede externe Instanz kann die gesamte Plugin-Logik auslösen, indem sie einfach ein JSON-Objekt übergibt, das eine Audio-Datei-ID enthält.
Eine Fähigkeit dient als formaler Vertrag zwischen der zugrunde liegenden PHP-Logik und jeder Instanz, die deren Ausführung anfordert. Der Vertrag legt fest, welche Daten die Fähigkeit als Eingabe erwartet, welchen Zweck sie verfolgt und welches Datenschema sie als Ausgabe zurückgibt.
Wenn du eine Fähigkeit registrierst, wird sie dem Fähigkeitsregister deiner Website hinzugefügt. Von diesem Moment an fungiert WordPress als sicheres Gateway: Es überprüft die Authentifizierung und validiert eingehende Daten anhand des im Vertrag festgelegten Schemas. WordPress leitet die Anfrage nur dann an die zugrunde liegende PHP-Funktion weiter, wenn die Nutzdaten streng dem Vertrag entsprechen.
Eine Fähigkeit ist plattformunabhängig. WordPress muss nicht wissen, welche konkrete Instanz den Zugriff anfordert; es überprüft lediglich, ob die Anfrage autorisiert ist und die Vorgaben des Vertrags erfüllt.
Durch die Registrierung einer Fähigkeit ist dein Plugin nicht mehr nur eine Erweiterung mit eigener interner Logik; es wird zu einem Dienstanbieter für das gesamte Ökosystem. Ob es sich nun um eine mobile Anwendung, ein Automatisierungsskript wie Make.com oder Zapier, einen KI-Agenten oder einen Server handelt, der über das MCP-Protokoll kommuniziert – diese Entitäten wissen genau, wie sie strukturierte Vorgänge auf deiner Website auslösen können.
Arbeiten mit der Abilities-API
Die Abilities-API bietet einen umfassenden Funktionsumfang, mit dem du registrierte Fähigkeiten auf deiner Website erkennen, aktivieren sowie Fähigkeiten registrieren und deregistrieren kannst.
Arbeite mit den Fähigkeiten deiner Website
Du kannst eine Liste aller registrierten Fähigkeiten abrufen oder ein einzelnes Fähigkeitsobjekt abrufen. Du kannst auch Bedingungen überprüfen, z. B. ob eine bestimmte Fähigkeit registriert ist oder ob der Agent die Berechtigungen hat, sie auszulösen.
Eine Liste der auf deiner Website registrierten Fähigkeiten abrufen
Die Funktion wp_get_abilities() gibt ein Array aller registrierten Fähigkeiten zurück. Du kannst sie mit WP-CLI testen. Sobald du dich per SSH mit deiner Website verbunden hast, wechsle mit den folgenden Befehlen in das Stammverzeichnis der Website, in dem sich deine Datei wp-config.php befindet:
cd /path/to/your/site
ls wp-config.phpStelle anschließend sicher, dass WP-CLI deine Website-Installation erkennt:
wp core is-installed
wp option get siteurlWenn du die URL deiner Website erhältst, kannst du loslegen und den folgenden Befehl ausführen:
wp eval '$abilities = wp_get_abilities(); foreach ( $abilities as $a ) { echo $a->get_name() . PHP_EOL; }'Dieser Befehl führt PHP-Code in deinem Terminal aus. Das PHP-Skript fragt die Namen aller registrierten Fähigkeiten auf deiner Website ab und sollte standardmäßig die folgende Antwort liefern:
core/get-site-info
core/get-user-info
core/get-environment-infoMit dem folgenden Befehl kannst du einen umfassenderen Datensatz abfragen:
wp eval '
$all_abilities = wp_get_abilities();
foreach ( $all_abilities as $ability ) {
echo "Ability Name: " . esc_html( $ability->get_name() ) . "n";
echo "Label: " . esc_html( $ability->get_label() ) . "n";
echo "Category: " . esc_html( $ability->get_category() ) . "n";
echo "Description: " . esc_html( $ability->get_description() ) . "n";
echo "---n";
}
'Wenn du diesen Befehl auf einer neuen WordPress-7.0 -Website ausführst, zeigt das Terminal die folgende Antwort an:
Ability Name: core/get-site-info
Label: Get Site Information
Category: site
Description: Returns site information configured in WordPress. By default returns all fields, or optionally a filtered subset.
---
Ability Name: core/get-user-info
Label: Get User Information
Category: user
Description: Returns profile details for the current authenticated user to support personalization, auditing, and access-aware behavior. By default returns all fields, or optionally a filtered subset.
---
Ability Name: core/get-environment-info
Label: Get Environment Info
Category: site
Description: Returns core details about the site's runtime context for diagnostics and compatibility (environment, PHP runtime, database server info, WordPress version). By default returns all fields, or optionally a filtered subset.
---Ein „Fähigkeits“-Objekt abrufen
Die Funktion wp_get_ability() gibt ein einzelnes Fähigkeit-Objekt anhand seines Namens zurück. Du kannst das in WP-CLI mit folgendem Befehl testen:
wp eval '
$ability = wp_get_ability( "core/get-site-info" );
if ( ! $ability ) {
echo "Ability not foundn";
exit( 1 );
}
echo "Name: " . $ability->get_name() . "n";
echo "Label: " . $ability->get_label() . "n";
echo "Category: " . $ability->get_category() . "n";
echo "Description: " . $ability->get_description() . "n";
echo "nInput Schema:n";
var_dump( $ability->get_input_schema() );
echo "nOutput Schema:n";
var_dump( $ability->get_output_schema() );
echo "nMeta:n";
var_dump( $ability->get_meta() );
'Wenn die Fähigkeit auf deiner Website korrekt registriert ist, erhältst du im Terminal folgende Antwort:
Name: core/get-site-info
Label: Get Site Information
Category: site
Description: Returns site information configured in WordPress. By default returns all fields, or optionally a filtered subset.
Input Schema:
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:
array(3) {
["type"]=>
string(6) "object"
["properties"]=>
array(8) {
["name"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(10) "Site Title"
["description"]=>
string(15) "The site title."
}
["description"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(7) "Tagline"
["description"]=>
string(17) "The site tagline."
}
["url"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(18) "Site Address (URL)"
["description"]=>
string(94) "The public URL where visitors access the site. May differ from the WordPress installation URL."
}
["wpurl"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(23) "WordPress Address (URL)"
["description"]=>
string(83) "The URL where WordPress core files are served. May differ from the public site URL."
}
["admin_email"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(28) "Administration Email Address"
["description"]=>
string(37) "The site administrator email address."
}
["charset"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(12) "Site Charset"
["description"]=>
string(28) "The site character encoding."
}
["language"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(13) "Site Language"
["description"]=>
string(42) "The site locale in dash form (e.g. en-US)."
}
["version"]=>
array(3) {
["type"]=>
string(6) "string"
["title"]=>
string(17) "WordPress Version"
["description"]=>
string(48) "The WordPress core version running on this site."
}
}
["additionalProperties"]=>
bool(false)
}
Meta:
array(2) {
["annotations"]=>
array(3) {
["readonly"]=>
bool(true)
["destructive"]=>
bool(false)
["idempotent"]=>
bool(true)
}
["show_in_rest"]=>
bool(true)
}Prüfen, ob eine Fähigkeit registriert ist
Mit der Funktion wp_has_ability() kannst du prüfen, ob eine Fähigkeit registriert ist. In WP-CLI kannst du sie wie folgt verwenden:
wp eval '
if ( wp_has_ability( "core/get-site-info" ) ) {
echo "✓ core/get-site-info is registeredn";
} else {
echo "✗ core/get-site-info not foundn";
}
'Wenn die Funktion registriert ist, erscheint folgende Meldung im Terminal:
✓ core/get-site-info is registeredAgentenberechtigungen prüfen
Du kannst überprüfen, ob der aktuelle Benutzer die Berechtigungen zum Ausführen einer Fähigkeit hat, indem du die Methode check_permissions() des Objekts $ability verwendest. Diese gibt „true“, „false“ oder ein WP_Error-Objekt zurück. Versuchen wir, diese Methode über das Terminal mit dem folgenden WP-CLI-Befehl aufzurufen:
wp --user=1 eval '
$ability = wp_get_ability( "core/get-site-info" );
if ( $ability ) {
$has_permissions = $ability->check_permissions();
if ( true === $has_permissions ) {
echo "You have permissions to execute this ability.";
} else {
if ( is_wp_error( $has_permissions ) ) {
error_log( "Permissions check failed: " . $has_permissions->get_error_message() );
}
echo "You do not have permissions to execute this ability.";
}
} else {
echo "Ability not found.";
}
'Hier haben wir --user=1 festgelegt, weshalb du die folgende Antwort erhältst:
You have permissions to execute this ability.Eine Fähigkeit registrieren
Jetzt ist es an der Zeit, eine Fähigkeit zu registrieren. Um einen Anwendungsfall aus der Praxis zu veranschaulichen, werden wir das in unserem Artikel über den WordPress-AI-Client beschriebene Plugin erweitern. Das Plugin sendet eine Audiodatei an das KI-Modell, um den Text zu extrahieren und die Erstellung von Gutenberg-Blöcken auszulösen. In diesem Abschnitt schauen wir uns an, wie man diesen Prozess als Fähigkeit registriert, damit jede Entität mit den erforderlichen Berechtigungen ihn finden und nutzen kann.
Bevor du eine neue Fähigkeit registrierst, musst du eine neue Fähigkeitskategorie registrieren.
Dazu musst du die Funktion wp_register_ability_category() in den Hook wp_abilities_api_categories_init einbinden.
Die Funktion akzeptiert einen eindeutigen Kategorie-Slug und ein assoziatives Array mit Argumenten.
So registrierst du deine Funktionskategorie:
function aicb_register_ability_category(): void {
if ( ! function_exists( 'wp_register_ability_category' ) ) {
return;
}
wp_register_ability_category(
'content-generation',
array(
'label' => 'Content Generation',
'description' => 'AI-powered content transformation and structuring abilities',
)
);
}
add_action( 'wp_abilities_api_categories_init', 'aicb_register_ability_category' );Der nächste Schritt ist die Registrierung der Funktion. Dazu bindest du die Funktion wp_register_ability() in die Aktion wp_abilities_api_init ein.
Die Funktion akzeptiert zwei Argumente: den Namen der Funktion einschließlich ihres Namensraums und ein Array mit Argumenten für die Konfiguration der Funktion.
So sieht die Funktionsregistrierung für das AI Content Builder-Plugin aus:
function aicb_register_audio_to_gutenberg_blocks_ability(): void {
if ( ! function_exists( 'wp_register_ability' ) ) {
return;
}
$input_schema = array( ... );
$output_schema = array( ... );
wp_register_ability(
'ai-content-builder/audio-to-gutenberg-blocks',
array(
'category' => 'content-generation',
'label' => 'Audio to Gutenberg Blocks',
'description' => 'Transcribes audio and converts the content into WordPress Gutenberg-compatible block objects.',
'input_schema' => $input_schema,
'output_schema' => $output_schema,
'execute_callback' => 'aicb_audio_to_gutenberg_blocks_callback',
'permission_callback' => static function (): bool {
return current_user_can( 'edit_posts' );
},
'meta' => array(
'show_in_rest' => true,
'annotations' => array(
'readonly' => false,
'destructive' => false,
'idempotent' => false,
'instructions' => 'Processes an audio attachment: transcribes it, generates structured blog content via AI, and returns Gutenberg-ready block objects.',
),
),
)
);
}
add_action( 'wp_abilities_api_init', 'aicb_register_audio_to_gutenberg_blocks_ability' );Im Aufruf der Funktion wp_register_ability haben wir die folgenden Argumente konfiguriert:
category: Die Kategorie, zu der die Funktion gehört.label: Der Anzeigename der Funktion.description: Eine kurze Beschreibung der Funktion der Fähigkeit und ihres Zwecks.input_schema: Das Datenschema für die eingehenden Eingabeargumente.output_schema: Das Datenschema, das von der Funktion bereitgestellt und zurückgegeben wird.execute_callback: Die Callback-Funktion, die ausgeführt wird, wenn die Fähigkeit ausgelöst wird.permission_callback: Eine Callback-Funktion, die ausgeführt wird, um zu überprüfen, ob der Agent über die erforderlichen Berechtigungen zum Ausführen der Funktion verfügt.meta: Ein Array mit zusätzlichen Metadatenfeldern für die Funktion.show_in_rest: Legt fest, ob die Funktion innerhalb der WordPress-REST-API verfügbar sein soll oder nicht.annotations: Ein Array mit beschreibenden Elementen, die das Verhalten der Funktion definieren.
input_schema ist ein Array, das den Eingabekontrakt der Funktion definiert. Es stellt die JSON-Schema-Definition zur Validierung der Eingabe der Funktion dar. In unserem konkreten Anwendungsfall ist es wie folgt definiert:
$input_schema = array(
'type' => 'object',
'properties' => array(
'audio_id' => array(
'type' => 'integer',
'description' => 'The ID of the audio attachment to process and convert into Gutenberg blocks.',
),
),
'required' => array( 'audio_id' ),
);Dieses JSON-Schema gibt das Format vor, dem die Eingabedaten entsprechen müssen, um diese Funktion nutzen zu können.
output_schema ist der von der Funktion zurückgegebene Ausgabekontrakt. In unserem Beispiel ist jedes Element ein Objekt, das einen JSON-Block darstellt:
$output_schema = array(
'type' => 'object',
'properties' => array(
'title' => array( 'type' => 'string' ),
'sections' => array(
'type' => 'array',
'items' => array( 'type' => 'object' ),
),
'blocks' => array(
'type' => 'array',
'items' => array( 'type' => 'object' ),
),
'transcript' => array( 'type' => 'string' ),
),
'required' => array( 'blocks' ),
);Der nächste Schritt ist die Definition der Callback-Funktion, die ausgeführt wird, wenn die Fähigkeit ausgelöst wird (den vollständigen Code findest du auf GitHub):
function aicb_audio_to_gutenberg_blocks_callback( array $args ) {
// missing code
// see GitHub
...
$structured_json = wp_ai_client_prompt( $prompt )
->using_system_instruction( $instructions )
->using_temperature( 0.4 )
->as_json_response( $schema )
->generate_text();
if ( is_wp_error( $structured_json ) ) {
return $structured_json;
}
$structured = json_decode( (string) $structured_json, true );
if ( ! is_array( $structured ) ) {
return new WP_Error(
'invalid_ai_json',
'Could not parse structured AI response.',
array( 'status' => 500 )
);
}
// Normalize the output.
$normalized = aicb_normalize_structured_post( $structured );
if ( '' === $normalized['title'] && empty( $normalized['sections'] ) ) {
return new WP_Error(
'empty_structured_content',
'The AI provider returned empty structured content.',
array( 'status' => 500 )
);
}
// Convert to Gutenberg blocks.
$blocks = aicb_sections_to_blocks( $normalized['title'], $normalized['sections'] );
return $blocks;
}Diese Funktion ruft zwei benutzerdefinierte Funktionen auf. Die erste (aicb_normalize_structured_post) normalisiert die Ausgabe der KI in ein vordefiniertes Format und bereinigt die Daten:
function aicb_normalize_structured_post( array $structured ): array {
$title = isset( $structured['title'] )
? sanitize_text_field( (string) $structured['title'] )
: '';
$sections = array();
if ( isset( $structured['sections'] ) && is_array( $structured['sections'] ) ) {
foreach ( $structured['sections'] as $section ) {
if ( ! is_array( $section ) ) {
continue;
}
$heading = isset( $section['heading'] )
? sanitize_text_field( (string) $section['heading'] )
: '';
$level = 2;
$paragraphs = array();
if ( isset( $section['paragraphs'] ) && is_array( $section['paragraphs'] ) ) {
foreach ( $section['paragraphs'] as $paragraph ) {
$clean_paragraph = trim( sanitize_textarea_field( (string) $paragraph ) );
if ( '' !== $clean_paragraph ) {
$paragraphs[] = $clean_paragraph;
}
}
}
$bullet_points = array();
if ( isset( $section['bullet_points'] ) && is_array( $section['bullet_points'] ) ) {
foreach ( $section['bullet_points'] as $bullet_point ) {
$clean_bullet_point = trim( sanitize_text_field( (string) $bullet_point ) );
if ( '' !== $clean_bullet_point ) {
$bullet_points[] = $clean_bullet_point;
}
}
}
if ( '' === $heading || empty( $paragraphs ) ) {
continue;
}
$sections[] = array(
'heading' => $heading,
'level' => $level,
'paragraphs' => $paragraphs,
'bullet_points' => $bullet_points,
);
}
}
return array(
'title' => $title,
'sections' => $sections,
);
}Die Funktion nimmt ein strukturiertes Array aus JSON-Objekten entgegen, normalisiert und bereinigt die Daten und gibt ein Array zurück, das den Titel und die Abschnitte enthält.
Die zweite Funktion (aicb_sections_to_blocks) wandelt die normalisierten Daten in Block-Deskriptor-Objekte um und ist wie folgt definiert:
function aicb_sections_to_blocks( string $title, array $sections ): array {
$blocks = array();
foreach ( $sections as $section ) {
if ( ! is_array( $section ) ) {
continue;
}
$heading = isset( $section['heading'] ) ? trim( (string) $section['heading'] ) : '';
if ( '' === $heading ) {
continue;
}
$paragraphs = array();
if ( isset( $section['paragraphs'] ) && is_array( $section['paragraphs'] ) ) {
foreach ( $section['paragraphs'] as $paragraph ) {
$clean = trim( (string) $paragraph );
if ( '' !== $clean ) {
$paragraphs[] = $clean;
}
}
}
if ( empty( $paragraphs ) ) {
continue;
}
$blocks[] = array(
'name' => 'core/heading',
'attributes' => array(
'content' => $heading,
'level' => 2,
),
);
foreach ( $paragraphs as $paragraph ) {
$blocks[] = array(
'name' => 'core/paragraph',
'attributes' => array(
'content' => $paragraph,
),
);
}
if ( isset( $section['bullet_points'] ) && is_array( $section['bullet_points'] ) ) {
$bullet_items_html = '';
foreach ( $section['bullet_points'] as $bullet_point ) {
$clean_bullet = trim( sanitize_text_field( (string) $bullet_point ) );
if ( '' === $clean_bullet ) {
continue;
}
// core/list expects HTML in the `values` attribute.
$bullet_items_html .= '<li>' . esc_html( $clean_bullet ) . '</li>';
}
if ( '' !== $bullet_items_html ) {
$blocks[] = array(
'name' => 'core/list',
'attributes' => array(
'values' => '<ul>' . $bullet_items_html . '</ul>',
),
);
}
}
}
return $blocks;
}Hier sind die wichtigsten Merkmale dieser Funktion:
- Die Funktion nimmt zwei Argumente entgegen: eine Zeichenkette, die den Titel des Beitrags darstellt, und ein Array mit den vom KI-Modell generierten Abschnitten.
- Für jeden Abschnitt generiert die Funktion eine Überschrift und mindestens einen Absatz.
- Wenn Aufzählungspunkte vorhanden sind, generiert sie eine entsprechende Anzahl von Listenelementen.
- Die Funktion gibt ein Array
$blocksmit Blockdeskriptor-Objekten zurück, das dem vom „Ability“-Objekt ($output_schema) zurückgegebenen Output-Contract entspricht.
Beachte, dass die Ausgabe der Funktion nicht das rohe Block-Markup ist. Dieses wird clientseitig mithilfe der JavaScript-Funktion createBlock generiert.
Das Überschriftenelement eines Abschnitts wird beispielsweise durch das folgende Objekt dargestellt:
if ( '' !== $heading ) {
$blocks[] = array(
'name' => 'core/heading',
'attributes' => array(
'content' => $heading,
'level' => ( 3 === $level ) ? 3 : 2,
),
);
}Sobald du Ihre Fähigkeit registriert hast, kannst du die oben gezeigten WP-CLI-Befehle in deinem Terminal ausführen, um die Details abzurufen. Der folgende Code generiert das Eingabeschema für deine Fähigkeit:
wp --user=1 eval '
$ability = wp_get_ability( "ai-content-builder/audio-to-gutenberg-blocks" );
if ( ! $ability ) {
echo "Ability not foundn";
exit( 1 );
}
echo "Input Schema:n";
var_dump( $ability->get_input_schema() );
'Hier ist das Ergebnis im Terminal:
Input Schema:
array(3) {
["type"]=>
string(6) "object"
["properties"]=>
array(1) {
["audio_id"]=>
array(2) {
["type"]=>
string(7) "integer"
["description"]=>
string(76) "The ID of the audio attachment to process and convert into Gutenberg blocks."
}
}
["required"]=>
array(1) {
[0]=>
string(8) "audio_id"
}
}Auf die gleiche Weise kannst du das Ausgabeschema der Fähigkeit abrufen:
wp --user=1 eval '
$ability = wp_get_ability( "ai-content-builder/audio-to-gutenberg-blocks" );
if ( ! $ability ) {
echo "Ability not foundn";
exit( 1 );
}
echo "Output Schema:n";
var_dump( $ability->get_output_schema() );
'Du kannst das vollständige Objekt deiner Fähigkeit auch mit dem folgenden Befehl anzeigen:
wp eval '
$ability = wp_get_ability( "ai-content-builder/audio-to-gutenberg-blocks" );
if ( ! $ability ) {
echo "Ability not foundn";
exit( 1 );
}
echo "Name: " . $ability->get_name() . "n";
echo "Label: " . $ability->get_label() . "n";
echo "Category: " . $ability->get_category() . "n";
echo "Description: " . $ability->get_description() . "n";
echo "nInput Schema:n";
var_dump( $ability->get_input_schema() );
echo "nOutput Schema:n";
var_dump( $ability->get_output_schema() );
'Eine Fähigkeit ausführen
Um eine Funktion auszuführen, verwendest du die Methode execute()des Objekts $ability. Du kannst versuchen, den folgenden PHP-Code über WP-CLI auszuführen, um die Funktion core/get-site-info auszulösen:
wp --user=1 eval '
$ability = wp_get_ability( "core/get-site-info" );
if ( ! $ability ) {
echo "Ability not foundn";
exit(1);
}
$result = $ability->execute();
if ( is_wp_error( $result ) ) {
echo "ERROR: " . $result->get_error_message() . "n";
exit(1);
}
echo json_encode( $result, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ) . "n";
'Wenn du diesen Befehl ausführst, liefert die Funktion ein JSON-Objekt, das in etwa so aussieht:
{
"name": "WordPress 7.0",
"description": "",
"url": "http://yoursite.kinsta.cloud",
"wpurl": "http://yoursite.kinsta.cloud",
"admin_email": "[email protected]",
"charset": "UTF-8",
"language": "en-US",
"version": "7.1-alpha-62550"
}Das oben Genannte ist nur ein einfaches Beispiel für eine Funktion, die Daten für deine Website bereitstellt.
Wie oben erwähnt, kann eine Funktion Eingabedaten benötigen, Operationen an diesen Daten durchführen und eine strukturierte Ausgabe zurückgeben. Ein Beispiel dafür sehen wir bei der Funktion, die wir im vorherigen Abschnitt registriert haben.
Navigiere im Terminal zum Stammverzeichnis deiner Website und führe den folgenden PHP-Code aus:
wp --user=1 eval '
$ability = wp_get_ability( "ai-content-builder/audio-to-gutenberg-blocks" );
if ( ! $ability ) {
echo "Ability not foundn";
exit( 1 );
}
$input = array( "audio_id" => 1755 );
$result = $ability->execute( $input );
if ( is_wp_error( $result ) ) {
echo "ERROR: " . $result->get_error_message() . "n";
exit( 1 );
}
echo json_encode( $result, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ) . "n";
'Die Methode execute übergibt die strukturierten Eingabedaten an die Funktion, die ein Array von Objekten zurückgibt, die bereit sind, in Gutenberg-Blöcke umgewandelt zu werden:
[
{
"name": "core/heading",
"attributes": {
"content": "A Well-Deserved Rest Day in Marrakech",
"level": 2
}
},
{
"name": "core/paragraph",
"attributes": {
"content": "On April 24th, our group of seven motorcyclists took a break from the open road..."
}
},
{
"name": "core/heading",
"attributes": {
"content": "Exploring Jemaa el-Fnaa and the Medina",
"level": 2
}
},
{
"name": "core/paragraph",
"attributes": {
"content": "Our journey led us straight to Jemaa el-Fnaa, the legendary main square of Marrakech..."
}
},
{
"name": "core/list",
"attributes": {
"values": "<ul><li>Navigating the bustling souks and narrow alleys of the ancient Medina.</li><li>Savoring traditional Moroccan and Berber dishes.</li><li>Experiencing the vibrant street performances and food stalls of Jemaa el-Fnaa at night.</li></ul>"
}
},
...
]REST-API-Integration
Die WordPress-Abilities-API bietet eine einheitliche Routing-Struktur, die es externen Akteuren ermöglicht, verfügbare Ability-Kategorien programmgesteuert abzufragen (/categories), bestimmte Ability-Verträge zu überprüfen (/abilities/{name}) und eine bestimmte Ability über den Standard-Run-Endpunkt auszuführen (/abilities/{name}/run).
Hier ist zum Beispiel eine GET-Anfrage, die die Liste der Kategorien von unserer Testseite zurückgibt:
https://yoursite.kinsta.cloud/wp-json/wp-abilities/v1/categories
Als wir die Funktion im vorherigen Beispiel registriert haben, haben wir den Parameter show_in_rest auf true gesetzt. Dadurch haben wir unsere Funktion automatisch über diese nativen WordPress-REST-API-Endpunkte unter dem zentralen Core-Namespace (wp-abilities/v1) zugänglich gemacht.
Das bedeutet, dass du benutzerdefinierte Routen nicht manuell von Grund auf neu registrieren musst, um eine Funktion aus einer externen Umgebung aufzurufen. Externe Agenten können deine Funktion mithilfe von Standard-HTTP-Anfragen erkennen und ausführen.
Du kannst den spezifischen Vertrag unserer Funktion mit der folgenden GET-Anfrage einsehen:
https://yoursite.kinsta.cloud/wp-json/wp-abilities/v1/abilities/ai-content-builder/audio-to-gutenberg-blocksSchließlich kannst du die Funktion mit einer authentifizierten POST-Anfrage auslösen:
https://yoursite.kinsta.cloud/wp-json/wp-abilities/v1/abilities/ai-content-builder/audio-to-gutenberg-blocks/runAchte beim Senden dieser Art von Anfrage darauf, dass du die Eingabedaten angegeben hast. In unserem Beispiel haben wir den folgenden JSON-Text im Anfragetext festgelegt:
{
"input": {
"audio_id": YOUR_AUDIO_ID
}
}
Unsere Funktion hat das Audiomaterial verarbeitet und an das auf der Website konfigurierte KI-Modell weitergeleitet. Das Modell gab eine strukturierte Ausgabe zurück, die anschließend normalisiert und bereinigt wurde, woraufhin schließlich das folgende Array von Objekten mit den Block-Attributen zurückgegeben wurde:
{
"blocks": [
{
"name": "core/heading",
"attributes": { "content": "A Welcome Rest Day in Marrakech", "level": 2 }
},
{
"name": "core/paragraph",
"attributes": { "content": "On April 24, our group of seven motorcyclists paused our journey..." }
}
]
}Und genau das ist das Ergebnis, das wir angestrebt haben.
Die Zukunft von WordPress ist agentisch
Während der AI Client und die neue Connector-Architektur KI-Verarbeitungsfunktionen in WordPress integrieren, definiert die Abilities-API neu, wie WordPress mit der Außenwelt interagiert. Wir erleben gerade einen drastischen Paradigmenwechsel: weg von einer traditionellen Webarchitektur – basierend auf manueller Benutzerinteraktion, bei der jede Integration benutzerdefinierte Endpunkte und manuelles Mapping erforderte – hin zu einer absichtsgesteuerten Architektur, die von Grund auf für die Automatisierung konzipiert wurde.
Für WordPress-Entwickler stellt die neue Abilities-API einen architektonischen Wendepunkt dar, der sich durch die Entkopplung von Funktionen von den Plugins, die deren Logik enthalten, die Durchsetzung von Sicherheit durch den Input/Output-Vertrag und die Ermöglichung nativer Interoperabilität im gesamten Ökosystem auszeichnet.
Zusammengenommen sorgen diese Funktionen dafür, dass die Abilities-API nicht nur eine weitere API ist, sondern eine echte verteilte Ausführungs-Engine, die einen Einblick in eine zunehmend agentenbasierte Zukunft für WordPress bietet.
Carlo ist ein leidenschaftlicher Liebhaber von Webdesign und Frontend-Entwicklung. Er beschäftigt sich seit über 10 Jahren mit WordPress, auch in Zusammenarbeit mit italienischen und europäischen Universitäten und Bildungseinrichtungen. Er hat Dutzende von Artikeln und Leitfäden über WordPress geschrieben, die sowohl auf italienischen und internationalen Websites als auch in gedruckten Magazinen veröffentlicht wurden. Du kannst Carlo auf X und LinkedIn finden.
