wp-typia 0.22.1 → 0.22.3

package/dist-bunli/{cli-add-5z3wpzkh.js → cli-add-p3re8act.js}

@@ -4,6 +4,7 @@ import {
   REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY,
   assertExternalLayerCompositionOptions,
   copyInterpolatedDirectory,
+  createScaffoldCompatibilityConfig,
   getDefaultAnswers,
   listInterpolatedDirectoryOutputs,
   normalizeOptionalCliString,
@@ -20,7 +21,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-886tjd8m.js";
+} from "./cli-tbd9x8b6.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -33,7 +34,7 @@ import {
 } from "./cli-1sm60g1z.js";
 import {
   snapshotProjectVersion
-} from "./cli-yzmkz95r.js";
+} from "./cli-prc42zqd.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -57,6 +58,8 @@ import {
   assertAdminViewDoesNotExist,
   assertAiFeatureDoesNotExist,
   assertBindingSourceDoesNotExist,
+  assertBlockStyleDoesNotExist,
+  assertBlockTransformDoesNotExist,
   assertEditorPluginDoesNotExist,
   assertPatternDoesNotExist,
   assertRestResourceDoesNotExist,
@@ -94,7 +97,7 @@ import {
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-5md428hf.js";
+} from "./cli-x0h03qqe.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -2376,8 +2379,10 @@ registerBlockBindingsSource( {
 `;
 }
 function resolveBindingTarget(options, namespace) {
-  const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
-  const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+  const blockName = normalizeOptionalCliString(options.blockName);
+  const attributeName = normalizeOptionalCliString(options.attributeName);
+  const hasBlock = blockName !== undefined;
+  const hasAttribute = attributeName !== undefined;
   if (!hasBlock && !hasAttribute) {
     return;
   }
@@ -2385,8 +2390,8 @@ function resolveBindingTarget(options, namespace) {
     throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
   }
   return {
-    attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
-    blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace)
+    attributeName: assertValidBindingAttributeName(attributeName ?? ""),
+    blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace)
   };
 }
 function formatBindingAttributeTypeMember(attributeName) {
@@ -4366,12 +4371,14 @@ async function runAddRestResourceCommand({
     throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
 var import_semver = __toESM(require_semver(), 1);
 import fs5 from "fs";
 import { promises as fsp6 } from "fs";
 import path10 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-types.ts
 var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
 var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 var ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
@@ -4379,17 +4386,8 @@ var ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
 var ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
 var WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities";
 var WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
-function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
-  if (!existingVersion) {
-    return requiredVersion;
-  }
-  const existingMinimum = import_semver.default.minVersion(existingVersion);
-  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
-  if (!existingMinimum || !requiredMinimum) {
-    return requiredVersion;
-  }
-  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
-}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-templates.ts
 function toAbilityCategorySlug(workspaceNamespace) {
   const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
   return `${normalizedNamespace || "workspace"}-workflows`;
@@ -4854,6 +4852,19 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `).concat(`
 `);
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+  if (!existingVersion) {
+    return requiredVersion;
+  }
+  const existingMinimum = import_semver.default.minVersion(existingVersion);
+  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
+  if (!existingMinimum || !requiredMinimum) {
+    return requiredVersion;
+  }
+  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
+}
 function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path10.join(projectDir, "src", "abilities");
   return [path10.join(abilitiesDir, "index.ts"), path10.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path10.join(abilitiesDir, "index.ts");
@@ -5065,21 +5076,29 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     }
     const sharedEntriesPattern = /(for\s*\(\s*const\s+relativePath\s+of\s+\[)([\s\S]*?)(\]\s*\)\s*\{)/u;
     const match = nextSource.match(sharedEntriesPattern);
-    if (!match || !match[2].includes("src/bindings/index.ts") || !match[2].includes("src/editor-plugins/index.ts")) {
+    if (!match || !/['"]src\/bindings\/index\.(?:ts|js)['"]/u.test(match[2]) || !/['"]src\/editor-plugins\/index\.(?:tsx|ts|js)['"]/u.test(match[2])) {
       throw new Error([
         `ensureAbilityBuildScriptAnchors could not patch ${path10.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    nextSource = nextSource.replace(sharedEntriesPattern, `$1
-		'src/bindings/index.ts',
-		'src/bindings/index.js',
-		'src/editor-plugins/index.ts',
-		'src/editor-plugins/index.js',
-		'src/abilities/index.ts',
-		'src/abilities/index.js',
-	$3`);
+    nextSource = nextSource.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      const missingAbilityEntries = [
+        "'src/abilities/index.ts'",
+        "'src/abilities/index.js'"
+      ].filter((entry) => !sharedEntries.includes(entry));
+      if (missingAbilityEntries.length === 0) {
+        return fullMatch;
+      }
+      const itemIndent = sharedEntries.match(/\n([ \t]*)['"]/u)?.[1] ?? "\t\t";
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const nextEntries = `${trimmedEntries}${separator}` + missingAbilityEntries.map((entry) => `
+${itemIndent}${entry},`).join("") + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
     return nextSource;
   });
 }
@@ -5108,8 +5127,7 @@ async function ensureAbilityWebpackAnchors(workspace) {
 			entries.push( [ entryName, entryPath ] );
 			break;
 		}
-	}
-$2`);
+	}$2`);
     }
     const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
     const match = source.match(sharedEntriesPattern);
@@ -5120,31 +5138,33 @@ $2`);
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    return source.replace(sharedEntriesPattern, `for ( const [ entryName, candidates ] of [
-		[
-			'bindings/index',
-			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
-		],
-		[
-			'editor-plugins/index',
-			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
-		],
-		[
-			'abilities/index',
-			[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
-		],
-	] ) {`);
+    return source.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      if (/['"]abilities\/index['"]/u.test(sharedEntries)) {
+        return fullMatch;
+      }
+      const tupleIndent = sharedEntries.match(/\n([ \t]*)\[/u)?.[1] ?? "\t\t";
+      const nestedIndent = `${tupleIndent}	`;
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const abilityTuple = [
+        `${tupleIndent}[`,
+        `${nestedIndent}'abilities/index',`,
+        `${nestedIndent}[ 'src/abilities/index.ts', 'src/abilities/index.js' ],`,
+        `${tupleIndent}],`
+      ].join(`
+`);
+      const nextEntries = `${trimmedEntries}${separator}
+${abilityTuple}` + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
   });
 }
-async function runAddAbilityCommand({
-  abilityName,
-  cwd = process.cwd()
+async function scaffoldAbilityWorkspace({
+  abilitySlug,
+  compatibilityPolicy,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
   const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const buildScriptPath = path10.join(workspace.projectDir, "scripts", "build-workspace.mjs");
@@ -5203,18 +5223,37 @@ async function runAddAbilityCommand({
     });
     await writeAbilityRegistry(workspace.projectDir, abilitySlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      abilityEntries: [buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)]
+      abilityEntries: [
+        buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)
+      ]
     });
-    return {
-      abilitySlug,
-      projectDir: workspace.projectDir
-    };
   } catch (error) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+async function runAddAbilityCommand({
+  abilityName,
+  cwd = process.cwd()
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
+  await scaffoldAbilityWorkspace({
+    abilitySlug,
+    compatibilityPolicy,
+    workspace
+  });
+  return {
+    abilitySlug,
+    projectDir: workspace.projectDir
+  };
+}
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
 import { promises as fsp8 } from "fs";
 import path13 from "path";
 
@@ -5435,6 +5474,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) {
@@ -5470,6 +5548,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,
@@ -5477,6 +5557,7 @@ function buildAiFeatureApiSource(aiFeatureSlug) {
 
 import type {
 	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureSupportMetadata,
 } from './api-types';
 import {
 	run${pascalCase}AiFeatureEndpoint,
@@ -5503,6 +5584,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: () => {
@@ -5518,6 +5607,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 );
 }
@@ -5536,6 +5682,10 @@ import type {
 } from './api-types';
 import {
 	aiFeatureRunEndpoint,
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
 } from './api';
 
 export type UseRun${pascalCase}AiFeatureMutationOptions =
@@ -5550,6 +5700,13 @@ export function useRun${pascalCase}AiFeatureMutation(
 ) {
 	return useEndpointMutation( aiFeatureRunEndpoint, options );
 }
+
+export {
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
+};
 `;
 }
 function buildAiFeatureSyncScriptSource() {
@@ -5953,7 +6110,7 @@ async function ensureAiFeatureSyncRestAnchors(workspace) {
   });
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-templates.ts
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -5962,18 +6119,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 );
@@ -6040,17 +6219,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,
 		);
 	}
 }
@@ -6066,7 +6339,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' ) ||
@@ -6126,47 +6399,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;
 	}
 }
 
@@ -6181,6 +6502,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 ) );
 	}
 }
@@ -6192,10 +6525,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 )
 			);
 		}
@@ -6209,22 +6548,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 )
 			);
 		}
@@ -6233,7 +6595,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 )
 			);
 		}
@@ -6244,14 +6612,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 )
 			);
 		}
@@ -6286,7 +6666,7 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
-		$telemetry = ${buildTelemetryFunctionName}( $result );
+		$telemetry = ${buildTelemetryFunctionName}( $result, $payload, $normalized_result );
 		if ( is_wp_error( $telemetry ) ) {
 			return $telemetry;
 		}
@@ -6331,17 +6711,14 @@ add_action( 'admin_notices', '${adminNoticeFunctionName}' );
 add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
 `;
 }
-async function runAddAiFeatureCommand({
-  aiFeatureName,
-  cwd = process.cwd(),
-  namespace
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
+async function scaffoldAiFeatureWorkspace({
+  aiFeatureSlug,
+  compatibilityPolicy,
+  namespace,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
-  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
   const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const packageJsonPath = path13.join(workspace.projectDir, "package.json");
@@ -6379,7 +6756,7 @@ async function runAddAiFeatureCommand({
     await fsp8.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
     await fsp8.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
     await fsp8.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, namespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
@@ -6388,7 +6765,7 @@ async function runAddAiFeatureCommand({
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
       variables: {
-        namespace: resolvedNamespace,
+        namespace,
         pascalCase,
         slugKebabCase: aiFeatureSlug,
         title: toTitleCase(aiFeatureSlug)
@@ -6401,14 +6778,11 @@ async function runAddAiFeatureCommand({
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
       aiFeatureEntries: [
-        buildAiFeatureConfigEntry(aiFeatureSlug, resolvedNamespace)
+        buildAiFeatureConfigEntry(aiFeatureSlug, namespace)
       ],
       transformSource: ensureBlockConfigCanAddRestManifests
     });
     return {
-      aiFeatureSlug,
-      namespace: resolvedNamespace,
-      projectDir: workspace.projectDir,
       warnings: packageScriptChanges.addedProjectToolsDependency ? [
         "Added `@wp-typia/project-tools` to devDependencies for `sync-ai`. If this workspace was already installed, rerun your package manager install command before the first `wp-typia sync ai`."
       ] : []
@@ -6419,6 +6793,32 @@ async function runAddAiFeatureCommand({
   }
 }
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+async function runAddAiFeatureCommand({
+  aiFeatureName,
+  cwd = process.cwd(),
+  namespace
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
+  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
+  const scaffoldResult = await scaffoldAiFeatureWorkspace({
+    aiFeatureSlug,
+    compatibilityPolicy,
+    namespace: resolvedNamespace,
+    workspace
+  });
+  return {
+    aiFeatureSlug,
+    namespace: resolvedNamespace,
+    projectDir: workspace.projectDir,
+    warnings: scaffoldResult.warnings
+  };
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
 var VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
@@ -6900,24 +7300,6 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path14.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
-  if (fs6.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path14.relative(projectDir, stylePath)}. Choose a different name.`);
-  }
-  if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
-    throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
-  }
-}
-function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  const transformPath = path14.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
-  if (fs6.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path14.relative(projectDir, transformPath)}. Choose a different name.`);
-  }
-  if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
-    throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
-  }
-}
 function assertFullBlockName(blockName, flagName) {
   const trimmed = blockName.trim();
   if (!trimmed) {
@@ -7165,4 +7547,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=DE205F0F5620636264756E2164756E21
+//# debugId=272EBA8B7C96349F64756E2164756E21