wp-typia 0.22.1 → 0.22.2

package/dist-bunli/.bunli/commands.gen.js

@@ -211339,6 +211339,27 @@ function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
     return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
   });
 }
+function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSource, requiredFragments) {
+  const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex2(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+  return source.replace(interfacePattern, (match3, start, body, end) => {
+    const fieldPattern = new RegExp(`(^([ \\t]*)${escapeRegex2(fieldName)}\\??:\\s*\\{[ \\t]*\\r?\\n)([\\s\\S]*?)(^\\2\\};\\r?\\n?)`, "mu");
+    const fieldMatch = fieldPattern.exec(body);
+    if (!fieldMatch) {
+      return match3;
+    }
+    const existingFieldSource = fieldMatch[0];
+    if (requiredFragments.every((fragment) => existingFieldSource.includes(fragment))) {
+      return match3;
+    }
+    const lineEnding = start.endsWith(`\r
+`) ? `\r
+` : `
+`;
+    const formattedFieldSource = `${fieldSource.replace(/\r?\n$/u, "").split(`
+`).join(lineEnding)}${lineEnding}`;
+    return `${start}${body.slice(0, fieldMatch.index)}${formattedFieldSource}${body.slice(fieldMatch.index + existingFieldSource.length)}${end}`;
+  });
+}
 function updateWorkspaceInventorySource(source, {
   blockEntries = [],
   blockStyleEntries = [],
@@ -211370,7 +211391,9 @@ function updateWorkspaceInventorySource(source, {
   nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
   nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
   nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+  nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
   nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+  nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
   nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
   return nextSource;
 }
@@ -211473,7 +211496,9 @@ export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
 			wordpress?: string;
 		};
 		mode: 'baseline' | 'optional' | 'required';
+		optionalFeatureIds: string[];
 		optionalFeatures: string[];
+		requiredFeatureIds: string[];
 		requiredFeatures: string[];
 		runtimeGates: string[];
 	};
@@ -224640,7 +224665,9 @@ function createScaffoldCompatibilityConfig(policy) {
   return {
     hardMinimums: capabilityPlan.hardMinimums,
     mode: getPolicyMode(capabilityPlan),
+    optionalFeatureIds: capabilityPlan.optionalFeatures.map((feature) => feature.id),
     optionalFeatures: capabilityPlan.optionalFeatures.map((feature) => feature.label),
+    requiredFeatureIds: capabilityPlan.requiredFeatures.map((feature) => feature.id),
     requiredFeatures: capabilityPlan.requiredFeatures.map((feature) => feature.label),
     runtimeGates: [
       ...capabilityPlan.requiredFeatures.flatMap(formatRuntimeGate),
@@ -235415,6 +235442,45 @@ export interface ${pascalCase}AiFeatureResponse {
 	result: ${pascalCase}AiFeatureResult;
 	telemetry: ${pascalCase}AiFeatureTelemetry;
 }
+
+export type ${pascalCase}AiFeatureSupportProbeMode = 'request-time';
+
+export type ${pascalCase}AiFeatureUnavailableErrorCode =
+	'ai_client_unavailable';
+
+export type ${pascalCase}AiFeatureUnavailableReasonCode =
+	| 'missing-wordpress-ai-client'
+	| 'request-time-support-probe';
+
+export interface ${pascalCase}AiFeatureSupportReason {
+	code: ${pascalCase}AiFeatureUnavailableReasonCode;
+	label: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	message: string & tags.MinLength< 1 > & tags.MaxLength< 4000 >;
+}
+
+export interface ${pascalCase}AiFeatureSupportMetadata {
+	featureLabel: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	featureSlug: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	compatibility: {
+		hardMinimums: {
+			php?: string;
+			wordpress?: string;
+		};
+		mode: 'baseline' | 'optional' | 'required';
+		optionalFeatureIds: string[];
+		optionalFeatures: string[];
+		requiredFeatureIds: string[];
+		requiredFeatures: string[];
+		runtimeGates: string[];
+	};
+	supportProbe: {
+		endpointMethod: 'POST';
+		endpointPath: string & tags.MinLength< 1 > & tags.MaxLength< 200 >;
+		mode: ${pascalCase}AiFeatureSupportProbeMode;
+		unavailableErrorCode: ${pascalCase}AiFeatureUnavailableErrorCode;
+	};
+	unavailableReasons: ${pascalCase}AiFeatureSupportReason[];
+}
 `;
 }
 function buildAiFeatureValidatorsSource(aiFeatureSlug) {
@@ -235450,6 +235516,8 @@ export const apiValidators = {
 }
 function buildAiFeatureApiSource(aiFeatureSlug) {
   const pascalCase = toPascalCase(aiFeatureSlug);
+  const compatibility = createScaffoldCompatibilityConfig(resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY));
+  const title = toTitleCase(aiFeatureSlug);
   return `import {
 	callEndpoint,
 	resolveRestRouteUrl,
@@ -235457,6 +235525,7 @@ function buildAiFeatureApiSource(aiFeatureSlug) {
 
 import type {
 	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureSupportMetadata,
 } from './api-types';
 import {
 	run${pascalCase}AiFeatureEndpoint,
@@ -235483,6 +235552,14 @@ function resolveRestNonce( fallback?: string ): string | undefined {
 		: undefined;
 }
 
+function isPlainObject( value: unknown ): value is Record< string, unknown > {
+	return (
+		!! value &&
+		typeof value === 'object' &&
+		! Array.isArray( value )
+	);
+}
+
 export const aiFeatureRunEndpoint = {
 	...run${pascalCase}AiFeatureEndpoint,
 	buildRequestOptions: () => {
@@ -235498,6 +235575,63 @@ export const aiFeatureRunEndpoint = {
 	},
 };
 
+export const aiFeatureSupportMetadata = {
+	compatibility: ${JSON.stringify(compatibility, null, "\t")},
+	featureLabel: ${quoteTsString(title)},
+	featureSlug: ${quoteTsString(aiFeatureSlug)},
+	supportProbe: {
+		endpointMethod: 'POST',
+		endpointPath: aiFeatureRunEndpoint.path,
+		mode: 'request-time',
+		unavailableErrorCode: 'ai_client_unavailable',
+	},
+	unavailableReasons: [
+		{
+			code: 'missing-wordpress-ai-client',
+			label: 'WordPress AI Client unavailable',
+			message:
+				'This AI feature stays disabled until the WordPress AI Client is available on the site.',
+		},
+		{
+			code: 'request-time-support-probe',
+			label: 'Support is checked at request time',
+			message:
+				'Support is verified when the feature runs, so editor and admin UIs should degrade gracefully when the site rejects the request.',
+		},
+	],
+} satisfies ${pascalCase}AiFeatureSupportMetadata;
+
+export function getAiFeatureSupportHintLines() {
+	return aiFeatureSupportMetadata.unavailableReasons.map(
+		( reason ) => reason.message
+	);
+}
+
+export function isAiFeatureSupportUnavailableError( error: unknown ) {
+	if ( ! isPlainObject( error ) ) {
+		return false;
+	}
+
+	const data = isPlainObject( error.data ) ? error.data : undefined;
+	return (
+		error.code === aiFeatureSupportMetadata.supportProbe.unavailableErrorCode ||
+		data?.status === 501
+	);
+}
+
+export function resolveAiFeatureUnavailableMessage( error: unknown ) {
+	if (
+		isPlainObject( error ) &&
+		typeof error.message === 'string' &&
+		error.message.length > 0
+	) {
+		return error.message;
+	}
+
+	return aiFeatureSupportMetadata.unavailableReasons[ 0 ]?.message ??
+		'This AI feature is currently unavailable.';
+}
+
 export function runAiFeature( request: ${pascalCase}AiFeatureRequest ) {
 	return callEndpoint( aiFeatureRunEndpoint, request );
 }
@@ -235516,6 +235650,10 @@ import type {
 } from './api-types';
 import {
 	aiFeatureRunEndpoint,
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
 } from './api';
 
 export type UseRun${pascalCase}AiFeatureMutationOptions =
@@ -235530,6 +235668,13 @@ export function useRun${pascalCase}AiFeatureMutation(
 ) {
 	return useEndpointMutation( aiFeatureRunEndpoint, options );
 }
+
+export {
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
+};
 `;
 }
 function buildAiFeatureSyncScriptSource() {
@@ -235953,18 +236098,40 @@ function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain
   const normalizeSchemaFunctionName = `${phpPrefix}_${aiFeaturePhpId}_sanitize_ai_feature_schema`;
   const validatePayloadFunctionName = `${phpPrefix}_${aiFeaturePhpId}_validate_ai_feature_payload`;
   const canManageFunctionName = `${phpPrefix}_${aiFeaturePhpId}_can_manage_ai_feature`;
+  const normalizePromptPayloadFunctionName = `${phpPrefix}_${aiFeaturePhpId}_normalize_ai_feature_prompt_payload`;
   const buildPromptFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_prompt`;
+  const resolvePromptOptionsFunctionName = `${phpPrefix}_${aiFeaturePhpId}_resolve_ai_feature_prompt_options`;
   const normalizeProviderTypeFunctionName = `${phpPrefix}_${aiFeaturePhpId}_normalize_provider_type`;
   const buildTelemetryFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_telemetry`;
+  const resolveUnavailableMessageFunctionName = `${phpPrefix}_${aiFeaturePhpId}_resolve_ai_feature_unavailable_message`;
   const isSupportedFunctionName = `${phpPrefix}_${aiFeaturePhpId}_is_ai_feature_supported`;
   const adminNoticeFunctionName = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_admin_notice`;
   const handlerFunctionName = `${phpPrefix}_${aiFeaturePhpId}_handle_run_ai_feature`;
   const registerRoutesFunctionName = `${phpPrefix}_${aiFeaturePhpId}_register_ai_feature_routes`;
+  const permissionFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_permission`;
+  const promptPayloadFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt_payload`;
+  const promptFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt`;
+  const promptOptionsFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt_options`;
+  const adminNoticeMessageFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_admin_notice_message`;
+  const unavailableMessageFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_unavailable_message`;
+  const telemetryFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_telemetry`;
   return `<?php
 if ( ! defined( 'ABSPATH' ) ) {
 	return;
 }
 
+/*
+ * Customization hooks for the ${aiFeatureTitle} AI feature:
+ *
+ * - ${quotePhpString(permissionFilterHook)} filters the default current_user_can( 'edit_posts' ) capability check.
+ * - ${quotePhpString(promptPayloadFilterHook)} filters the validated request payload array before prompt serialization.
+ * - ${quotePhpString(promptFilterHook)} filters the final prompt string after payload normalization.
+ * - ${quotePhpString(promptOptionsFilterHook)} filters prompt options with \`temperature\` and \`modelPreference\` keys.
+ * - ${quotePhpString(adminNoticeMessageFilterHook)} filters the wp-admin notice shown when AI support is unavailable.
+ * - ${quotePhpString(unavailableMessageFilterHook)} filters REST-facing unavailable messages by reason code.
+ * - ${quotePhpString(telemetryFilterHook)} filters the response telemetry array before schema validation. Return a schema-compatible array.
+ */
+
 if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
 	function ${loadSchemaFunctionName}( $schema_name ) {
 		$project_root = dirname( __DIR__, 2 );
@@ -236031,17 +236198,111 @@ if ( ! function_exists( '${validatePayloadFunctionName}' ) ) {
 }
 
 if ( ! function_exists( '${canManageFunctionName}' ) ) {
-	function ${canManageFunctionName}() {
-		return current_user_can( 'edit_posts' );
+	function ${canManageFunctionName}( WP_REST_Request $request = null ) {
+		$permission = apply_filters(
+			${quotePhpString(permissionFilterHook)},
+			current_user_can( 'edit_posts' ),
+			$request
+		);
+		if ( is_wp_error( $permission ) ) {
+			return $permission;
+		}
+		return (bool) $permission;
+	}
+}
+
+if ( ! function_exists( '${normalizePromptPayloadFunctionName}' ) ) {
+	function ${normalizePromptPayloadFunctionName}( array $payload ) {
+		$normalized_payload = apply_filters(
+			${quotePhpString(promptPayloadFilterHook)},
+			$payload
+		);
+		return is_array( $normalized_payload ) ? $normalized_payload : $payload;
 	}
 }
 
 if ( ! function_exists( '${buildPromptFunctionName}' ) ) {
 	function ${buildPromptFunctionName}( array $payload ) {
-		return sprintf(
+		$normalized_payload = ${normalizePromptPayloadFunctionName}( $payload );
+		$prompt = sprintf(
 			'You are helping with the %1$s AI workflow. Read the JSON request payload and return JSON that matches the provided schema. Request payload: %2$s',
 			${quotePhpString(aiFeatureTitle)},
-			wp_json_encode( $payload )
+			wp_json_encode( $normalized_payload )
+		);
+		$filtered_prompt = apply_filters(
+			${quotePhpString(promptFilterHook)},
+			$prompt,
+			$normalized_payload,
+			$payload
+		);
+		return is_string( $filtered_prompt ) && '' !== $filtered_prompt ? $filtered_prompt : $prompt;
+	}
+}
+
+if ( ! function_exists( '${resolvePromptOptionsFunctionName}' ) ) {
+	function ${resolvePromptOptionsFunctionName}( array $payload = array() ) {
+		$options = apply_filters(
+			${quotePhpString(promptOptionsFilterHook)},
+			array(
+				'modelPreference' => array(),
+				'temperature'     => 0.2,
+			),
+			$payload
+		);
+		if ( ! is_array( $options ) ) {
+			$options = array();
+		}
+
+		$temperature = 0.2;
+		if ( array_key_exists( 'temperature', $options ) ) {
+			if ( null === $options['temperature'] ) {
+				$temperature = null;
+			} elseif ( is_numeric( $options['temperature'] ) ) {
+				$temperature = (float) $options['temperature'];
+			}
+		}
+
+		$model_preferences = array();
+		if ( isset( $options['modelPreference'] ) ) {
+			$raw_model_preferences = $options['modelPreference'];
+			if ( is_string( $raw_model_preferences ) && '' !== $raw_model_preferences ) {
+				$model_preferences = array( $raw_model_preferences );
+			} elseif ( is_array( $raw_model_preferences ) ) {
+				$model_preferences = array_values(
+					array_filter(
+						array_map(
+							static function ( $candidate ) {
+								if ( is_string( $candidate ) && '' !== $candidate ) {
+									return $candidate;
+								}
+								if ( ! is_array( $candidate ) ) {
+									return null;
+								}
+
+								$normalized = array_values(
+									array_filter(
+										$candidate,
+										static function ( $value ) {
+											return is_string( $value ) && '' !== $value;
+										}
+									)
+								);
+
+								return count( $normalized ) > 0 ? $normalized : null;
+							},
+							$raw_model_preferences
+						),
+						static function ( $candidate ) {
+							return null !== $candidate;
+						}
+					)
+				);
+			}
+		}
+
+		return array(
+			'modelPreference' => $model_preferences,
+			'temperature'     => $temperature,
 		);
 	}
 }
@@ -236057,7 +236318,7 @@ if ( ! function_exists( '${normalizeProviderTypeFunctionName}' ) ) {
 }
 
 if ( ! function_exists( '${buildTelemetryFunctionName}' ) ) {
-	function ${buildTelemetryFunctionName}( $result ) {
+	function ${buildTelemetryFunctionName}( $result, array $payload = array(), array $normalized_result = array() ) {
 		if (
 			! is_object( $result ) ||
 			! method_exists( $result, 'getId' ) ||
@@ -236117,47 +236378,95 @@ if ( ! function_exists( '${buildTelemetryFunctionName}' ) ) {
 			}
 		}
 
-		return $telemetry;
+		$filtered_telemetry = apply_filters(
+			${quotePhpString(telemetryFilterHook)},
+			$telemetry,
+			$result,
+			$payload,
+			$normalized_result
+		);
+		return is_array( $filtered_telemetry ) ? $filtered_telemetry : $telemetry;
+	}
+}
+
+if ( ! function_exists( '${resolveUnavailableMessageFunctionName}' ) ) {
+	function ${resolveUnavailableMessageFunctionName}( $message, $reason, array $context = array() ) {
+		$filtered_message = apply_filters(
+			${quotePhpString(unavailableMessageFilterHook)},
+			$message,
+			$reason,
+			$context
+		);
+		return is_string( $filtered_message ) && '' !== $filtered_message ? $filtered_message : $message;
 	}
 }
 
 if ( ! function_exists( '${isSupportedFunctionName}' ) ) {
-	function ${isSupportedFunctionName}() {
+	function ${isSupportedFunctionName}( array $payload = array(), $cache_result = true ) {
 		static $is_supported = null;
-		if ( null !== $is_supported ) {
+		$use_cache = $cache_result && count( $payload ) === 0;
+		if ( $use_cache && null !== $is_supported ) {
 			return $is_supported;
 		}
 
 		if ( ! function_exists( 'wp_ai_client_prompt' ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		$schema = ${loadAiSchemaFunctionName}();
 		if ( ! is_array( $schema ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		$prompt = wp_ai_client_prompt( 'AI feature support probe.' );
 		if ( ! is_object( $prompt ) || ! method_exists( $prompt, 'as_json_response' ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
+		}
+		$prompt_options = ${resolvePromptOptionsFunctionName}( $payload );
+		if (
+			array_key_exists( 'temperature', $prompt_options ) &&
+			null !== $prompt_options['temperature'] &&
+			method_exists( $prompt, 'using_temperature' )
+		) {
+			$prompt = $prompt->using_temperature( $prompt_options['temperature'] );
+		}
+		if (
+			! empty( $prompt_options['modelPreference'] ) &&
+			method_exists( $prompt, 'using_model_preference' )
+		) {
+			$prompt = $prompt->using_model_preference( ...$prompt_options['modelPreference'] );
 		}
 
 		$structured_prompt = $prompt->as_json_response( $schema );
 		if ( ! is_object( $structured_prompt ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		if ( method_exists( $structured_prompt, 'is_supported_for_text_generation' ) ) {
-			$is_supported = (bool) $structured_prompt->is_supported_for_text_generation();
-			return $is_supported;
+			$supported = (bool) $structured_prompt->is_supported_for_text_generation();
+			if ( $use_cache ) {
+				$is_supported = $supported;
+			}
+			return $supported;
 		}
 
-		$is_supported = method_exists( $structured_prompt, 'generate_text_result' );
-		return $is_supported;
+		$supported = method_exists( $structured_prompt, 'generate_text_result' );
+		if ( $use_cache ) {
+			$is_supported = $supported;
+		}
+		return $supported;
 	}
 }
 
@@ -236172,6 +236481,18 @@ if ( ! function_exists( '${adminNoticeFunctionName}' ) ) {
 			__( 'The %s AI feature is optional and remains disabled until the WordPress AI Client is available with structured text generation support for the generated schema.', ${quotePhpString(textDomain)} ),
 			${quotePhpString(aiFeatureTitle)}
 		);
+		$filtered_message = apply_filters(
+			${quotePhpString(adminNoticeMessageFilterHook)},
+			$message,
+			array(
+				'featureSlug'  => ${quotePhpString(aiFeatureSlug)},
+				'featureTitle' => ${quotePhpString(aiFeatureTitle)},
+				'namespace'    => ${quotePhpString(namespace)},
+			)
+		);
+		if ( is_string( $filtered_message ) && '' !== $filtered_message ) {
+			$message = $filtered_message;
+		}
 		printf( '<div class="notice notice-warning"><p>%s</p></div>', esc_html( $message ) );
 	}
 }
@@ -236183,10 +236504,16 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			return $payload;
 		}
 
-		if ( ! ${isSupportedFunctionName}() ) {
+		if ( ! ${isSupportedFunctionName}( $payload, false ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The WordPress AI Client is unavailable or does not support this feature endpoint.',
+				${resolveUnavailableMessageFunctionName}(
+					'The WordPress AI Client is unavailable or does not support this feature endpoint.',
+					'support_probe_failed',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -236200,22 +236527,45 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
+		$prompt_options = ${resolvePromptOptionsFunctionName}( $payload );
 		$prompt = wp_ai_client_prompt( ${buildPromptFunctionName}( $payload ) );
 		if ( ! is_object( $prompt ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The WordPress AI Client prompt builder is unavailable on this site.',
+				${resolveUnavailableMessageFunctionName}(
+					'The WordPress AI Client prompt builder is unavailable on this site.',
+					'prompt_builder_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
 
-		if ( method_exists( $prompt, 'using_temperature' ) ) {
-			$prompt = $prompt->using_temperature( 0.2 );
+		if (
+			array_key_exists( 'temperature', $prompt_options ) &&
+			null !== $prompt_options['temperature'] &&
+			method_exists( $prompt, 'using_temperature' )
+		) {
+			$prompt = $prompt->using_temperature( $prompt_options['temperature'] );
+		}
+		if (
+			! empty( $prompt_options['modelPreference'] ) &&
+			method_exists( $prompt, 'using_model_preference' )
+		) {
+			$prompt = $prompt->using_model_preference( ...$prompt_options['modelPreference'] );
 		}
 		if ( ! method_exists( $prompt, 'as_json_response' ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client does not expose as_json_response().',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client does not expose as_json_response().',
+					'as_json_response_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -236224,7 +236574,13 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 		if ( ! is_object( $structured_prompt ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client could not prepare a structured-output prompt.',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client could not prepare a structured-output prompt.',
+					'structured_prompt_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -236235,14 +236591,26 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 		) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client provider or model does not support this structured-output feature.',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client provider or model does not support this structured-output feature.',
+					'text_generation_unsupported',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
 		if ( ! method_exists( $structured_prompt, 'generate_text_result' ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client does not expose generate_text_result() after as_json_response().',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client does not expose generate_text_result() after as_json_response().',
+					'generate_text_result_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -236277,7 +236645,7 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
-		$telemetry = ${buildTelemetryFunctionName}( $result );
+		$telemetry = ${buildTelemetryFunctionName}( $result, $payload, $normalized_result );
 		if ( is_wp_error( $telemetry ) ) {
 			return $telemetry;
 		}
@@ -293449,7 +293817,7 @@ import path10 from "path";
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.22.1",
+  version: "0.22.2",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -293519,7 +293887,7 @@ var package_default2 = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.22.1",
+    "@wp-typia/project-tools": "0.22.2",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -296071,4 +296439,4 @@ export {
   cli
 };
 
-//# debugId=7FC90D52A694344264756E2164756E21
+//# debugId=95E6742032974D4764756E2164756E21

package/dist-bunli/{cli-yzmkz95r.js → cli-6hcbjvym.js}

@@ -54,7 +54,7 @@ import {
 } from "./cli-sj5mtyzj.js";
 import {
   readWorkspaceInventory
-} from "./cli-5md428hf.js";
+} from "./cli-smzkbfna.js";
 import {
   getInvalidWorkspaceProjectReason,
   tryResolveWorkspaceProject