@uemcp/server 1.9.0 → 1.10.0

package/dist/index.mjs

@@ -372,7 +372,13 @@ const TOOL_METADATA = {
 	add_sequence_binding: mutates("sequence", "add_sequence_binding"),
 	add_sequence_keys: mutates("sequence", "add_sequence_keys"),
 	add_sequence_track: mutates("sequence", "add_sequence_track"),
+	add_state_tree_component: mutates("ai", "add_state_tree_component"),
 	add_state_tree_state: mutates("ai", "add_state_tree_state"),
+	add_stimuli_source: mutates("ai", "add_stimuli_source", [
+		"noise",
+		"sound",
+		"source"
+	]),
 	add_widget: mutates("ui", "add_widget"),
 	analyze_trace: readOnly("core", void 0, [
 		"profile",
@@ -416,6 +422,11 @@ const TOOL_METADATA = {
 		"screenshot"
 	]),
 	compile_blueprint: idempotentMutates("blueprint", "compile_blueprint"),
+	configure_ai_perception: mutates("ai", "configure_ai_perception", [
+		"sight",
+		"hearing",
+		"senses"
+	]),
 	connect_pins: mutates("blueprint", "connect_pins"),
 	control_blueprint_debugger: mutates("blueprint", "control_blueprint_debugger", [
 		"step",
@@ -424,6 +435,17 @@ const TOOL_METADATA = {
 	]),
 	convert_to_nanite: idempotentMutates("asset", "convert_to_nanite"),
 	cook_content: mutates("build", void 0, ["cook", "platform"]),
+	create_ai_controller: mutates("ai", "create_ai_controller", [
+		"ai controller",
+		"brain",
+		"possess"
+	]),
+	create_ai_node_class: mutates("build", void 0, [
+		"state tree",
+		"behavior tree",
+		"eqs",
+		"scaffold"
+	]),
 	create_anim_blueprint: mutates("anim", "create_anim_blueprint"),
 	create_asset: mutates("asset", "create_asset"),
 	create_attribute_set: mutates("gas", "create_attribute_set"),
@@ -462,6 +484,12 @@ const TOOL_METADATA = {
 	create_sound_cue: mutates("audio", "create_sound_cue"),
 	create_state_tree: mutates("ai", "create_state_tree"),
 	create_struct: mutates("blueprint", "create_struct"),
+	create_team_agent_class: mutates("build", void 0, [
+		"team",
+		"attitude",
+		"affiliation",
+		"scaffold"
+	]),
 	create_widget_blueprint: mutates("ui", "create_widget_blueprint"),
 	delete_asset: destroys("asset", "delete_asset"),
 	delete_data_table: destroys("asset", "delete_data_table"),
@@ -476,6 +504,11 @@ const TOOL_METADATA = {
 	]),
 	duplicate_actor: mutates("level", "duplicate_actor"),
 	duplicate_asset: mutates("asset", "duplicate_asset"),
+	edit_eqs_query: mutates("ai", "edit_eqs_query", [
+		"test",
+		"generator",
+		"score"
+	]),
 	enable_toolset: idempotentMutates("core", void 0, [
 		"toolset",
 		"tools",
@@ -518,6 +551,7 @@ const TOOL_METADATA = {
 	get_asset_dependencies: readOnly("asset", "get_asset_dependencies"),
 	get_asset_metadata: readOnly("core", "get_asset_metadata"),
 	get_asset_property: readOnly("asset", "get_asset_property"),
+	get_behavior_tree: readOnly("ai", "get_behavior_tree"),
 	get_blueprint_compile_errors: readOnly("blueprint", "get_blueprint_compile_errors", [
 		"error",
 		"broken",
@@ -532,6 +566,11 @@ const TOOL_METADATA = {
 	get_blueprint_graph: readOnly("blueprint", "get_blueprint_graph"),
 	get_blueprint_summary: readOnly("blueprint", "get_blueprint_summary"),
 	get_build_job_status: readOnly("level", "get_build_job_status"),
+	get_bt_runtime_state: mutates("ai", "get_bt_runtime_state", [
+		"pie",
+		"runtime",
+		"debug"
+	]),
 	get_cdo_defaults: readOnly("core", "get_cdo_defaults"),
 	get_class_reflection: readOnly("core", "get_class_reflection", [
 		"uclass",
@@ -554,6 +593,7 @@ const TOOL_METADATA = {
 	get_create_class_status: readOnly("build", "get_create_class_status"),
 	get_current_level: readOnly("core", "get_current_level"),
 	get_editor_state: readOnly("core", "get_editor_state"),
+	get_eqs_query: readOnly("ai", "get_eqs_query"),
 	get_import_job_status: readOnly("asset", "get_import_job_status"),
 	get_net_stats: readOnly("test", "get_net_stats", [
 		"network",
@@ -568,6 +608,7 @@ const TOOL_METADATA = {
 	get_render_job_status: readOnly("sequence", "get_render_job_status"),
 	get_source_control_job_status: readOnly("asset", "get_source_control_job_status"),
 	get_source_control_status: readOnly("asset", "get_source_control_status"),
+	get_state_tree: readOnly("ai", "get_state_tree"),
 	get_stat_snapshot: readOnly("core", "stat_snapshot", [
 		"fps",
 		"performance",
@@ -588,6 +629,7 @@ const TOOL_METADATA = {
 		"enhanced input"
 	]),
 	launch_on_device: reachesOutside("test", false, "launch_on_device"),
+	link_state_tree_state: mutates("ai", "link_state_tree_state", ["subtree", "linked"]),
 	list_actors: readOnly("core", "list_actors"),
 	list_asset_factories: readOnly("asset", "list_asset_factories"),
 	list_automation_tests: readOnly("test", "list_automation_tests"),
@@ -645,6 +687,11 @@ const TOOL_METADATA = {
 		"unreal"
 	]),
 	run_editor_commandlet: mutates("build"),
+	run_eqs_query: readOnly("ai", "run_eqs_query", [
+		"query",
+		"score",
+		"items"
+	]),
 	run_geometry_script: mutates("level", "run_geometry_script"),
 	run_pcg_generate: mutates("fx", "run_pcg_generate"),
 	save_asset: idempotentMutates("asset", "save_asset"),
@@ -678,6 +725,8 @@ const TOOL_METADATA = {
 	set_pin_default: idempotentMutates("blueprint", "set_pin_default"),
 	set_post_process_settings: idempotentMutates("fx", "set_post_process_settings"),
 	set_project_settings: idempotentMutates("core", "set_project_settings"),
+	set_state_tree_considerations: mutates("ai", "set_state_tree_considerations", ["utility", "score"]),
+	set_state_tree_globals: mutates("ai", "set_state_tree_globals", ["evaluator", "global task"]),
 	set_view_mode: idempotentMutates("level", "set_view_mode"),
 	set_viewport_camera: idempotentMutates("level", "set_viewport_camera"),
 	set_widget_slot: idempotentMutates("ui", "set_widget_slot"),
@@ -703,6 +752,11 @@ const TOOL_METADATA = {
 		"tail"
 	]),
 	toggle_show_flags: idempotentMutates("level", "toggle_show_flags"),
+	trace_state_tree: mutates("ai", "trace_state_tree", [
+		"pie",
+		"runtime",
+		"brain"
+	]),
 	trigger_hot_reload: mutates("build", "start_hot_reload"),
 	trigger_live_compile: mutates("build", "start_live_compile", ["live coding", "recompile"]),
 	undo: mutates("core", "undo"),
@@ -1443,6 +1497,15 @@ const createdUserAssetResponseFields = {
 	version: z.literal(2)
 };
 const instancedObjectParamsSchema = z.record(z.string().trim().min(1).max(128), z.string().max(BRIDGE_FACTORY_OPTION_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 32, { message: `An instanced object carries at most ${String(32)} params.` }).default({});
+const BRIDGE_AI_REPORT_STATES = ["reported", "unsupported"];
+const BRIDGE_AI_RUNTIME_STATES = [
+	"reported",
+	"not_running",
+	"unsupported"
+];
+const aiReportStateSchema = z.enum(BRIDGE_AI_REPORT_STATES);
+const aiRuntimeStateSchema = z.enum(BRIDGE_AI_RUNTIME_STATES);
+const aiParamsSchema = z.record(z.string(), z.string());
 //#endregion
 //#region src/protocol/logs.ts
 const BRIDGE_SUBSCRIBE_LOGS_REQUEST_TYPE = "subscribe_logs";
@@ -7082,7 +7145,7 @@ const BRIDGE_STATE_TREE_TRANSITION_TRIGGERS = [
 ];
 const blackboardKeyTypeSchema = z.enum(BRIDGE_BLACKBOARD_KEY_TYPES);
 const blackboardKeyModeSchema = z.enum(BRIDGE_BLACKBOARD_KEY_MODES);
-const eqsTestPurposeSchema = z.enum(BRIDGE_EQS_TEST_PURPOSES);
+const eqsTestPurposeSchema$1 = z.enum(BRIDGE_EQS_TEST_PURPOSES);
 const stateTreeSchemaSchema = z.enum(BRIDGE_STATE_TREE_SCHEMAS);
 const stateTreeStateTypeSchema = z.enum(BRIDGE_STATE_TREE_STATE_TYPES);
 const stateTreeTransitionTriggerSchema = z.enum(BRIDGE_STATE_TREE_TRANSITION_TRIGGERS);
@@ -7128,7 +7191,7 @@ const bridgeEqsGeneratorSchema = z.object({
 });
 const bridgeEqsTestSchema = z.object({
 	params: eqsParamsSchema.default({}),
-	purpose: eqsTestPurposeSchema.default("filter_and_score"),
+	purpose: eqsTestPurposeSchema$1.default("filter_and_score"),
 	testClass: assetPathSchema
 });
 const bridgeCreateEqsQueryRequestSchema = z.object({
@@ -7276,230 +7339,846 @@ function createBridgeAddStateTreeStateRequest(assetPath, states, options = {}, r
 	});
 }
 //#endregion
-//#region src/protocol/sequencer.ts
-const BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE = "create_level_sequence";
-const BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE = "add_sequence_binding";
-const BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE = "add_sequence_track";
-const BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE = "add_sequence_keys";
-const BRIDGE_SEQUENCE_BINDING_KINDS = ["possessable", "spawnable"];
-const BRIDGE_SEQUENCE_TRACK_KINDS = [
-	"transform",
-	"skeletal_animation",
-	"camera_cut",
-	"audio",
-	"visibility",
-	"property"
+//#region src/protocol/stateTree.ts
+const BRIDGE_GET_STATE_TREE_REQUEST_TYPE = "get_state_tree";
+const BRIDGE_SET_STATE_TREE_GLOBALS_REQUEST_TYPE = "set_state_tree_globals";
+const BRIDGE_SET_STATE_TREE_CONSIDERATIONS_REQUEST_TYPE = "set_state_tree_considerations";
+const BRIDGE_LINK_STATE_TREE_STATE_REQUEST_TYPE = "link_state_tree_state";
+const BRIDGE_ADD_STATE_TREE_COMPONENT_REQUEST_TYPE = "add_state_tree_component";
+const BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE = "trace_state_tree";
+const BRIDGE_STATE_TREE_SELECTION_BEHAVIORS = [
+	"none",
+	"try_enter_state",
+	"try_select_children_in_order",
+	"try_select_children_at_random",
+	"try_select_children_with_highest_utility",
+	"try_select_children_at_random_weighted_by_utility",
+	"try_follow_transitions"
 ];
-const BRIDGE_SEQUENCE_TIME_UNITS = ["frames", "seconds"];
-const BRIDGE_SEQUENCE_INTERPOLATIONS = [
-	"auto",
-	"user",
-	"break",
-	"linear",
-	"constant"
+const BRIDGE_STATE_TREE_GLOBAL_KINDS = ["evaluator", "global_task"];
+const BRIDGE_STATE_TREE_GLOBAL_MODES = ["merge", "replace"];
+const BRIDGE_STATE_TREE_LINK_TYPES = ["linked_state", "linked_asset"];
+const BRIDGE_STATE_TREE_COMPONENT_KINDS = ["state_tree", "state_tree_ai"];
+const BRIDGE_STATE_TREE_TRACE_ACTIONS = [
+	"start",
+	"stop",
+	"poll"
 ];
-const BRIDGE_SEQUENCE_MAX_FRAME_RATE = 24e4;
-const BRIDGE_SEQUENCE_MAX_FRAME = 1e7;
-const sequenceBindingKindSchema = z.enum(BRIDGE_SEQUENCE_BINDING_KINDS);
-const sequenceTrackKindSchema = z.enum(BRIDGE_SEQUENCE_TRACK_KINDS);
-const sequenceTimeUnitSchema = z.enum(BRIDGE_SEQUENCE_TIME_UNITS);
-const sequenceInterpolationSchema = z.enum(BRIDGE_SEQUENCE_INTERPOLATIONS);
-const sequenceBindingIdSchema = z.string().trim().min(1).max(64);
-const sequenceFrameSchema = z.number().int().min(-1e7).max(BRIDGE_SEQUENCE_MAX_FRAME);
-const bridgeSequenceFrameRateSchema = z.object({
-	denominator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE),
-	numerator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE)
+const BRIDGE_STATE_TREE_TRACE_KINDS = [
+	"state_entered",
+	"state_exited",
+	"transition_taken",
+	"task_completed",
+	"condition_evaluated"
+];
+const stateTreeSelectionBehaviorSchema = z.enum(BRIDGE_STATE_TREE_SELECTION_BEHAVIORS);
+const stateTreeGlobalKindSchema = z.enum(BRIDGE_STATE_TREE_GLOBAL_KINDS);
+const stateTreeGlobalModeSchema = z.enum(BRIDGE_STATE_TREE_GLOBAL_MODES);
+const stateTreeLinkTypeSchema = z.enum(BRIDGE_STATE_TREE_LINK_TYPES);
+const stateTreeComponentKindSchema = z.enum(BRIDGE_STATE_TREE_COMPONENT_KINDS);
+const stateTreeTraceActionSchema = z.enum(BRIDGE_STATE_TREE_TRACE_ACTIONS);
+const stateTreeTraceKindSchema = z.enum(BRIDGE_STATE_TREE_TRACE_KINDS);
+const bridgeGetStateTreeRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_STATE_TREE_REQUEST_TYPE),
+	version: z.literal(2)
 });
-const bridgeCreateLevelSequenceRequestSchema = z.object({
-	assetName: assetNameSchema,
-	displayRate: bridgeSequenceFrameRateSchema.optional(),
-	durationInFrames: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME).optional(),
-	packagePath: contentPathSchema,
+const bridgeStateTreeNodeReportSchema = z.object({
+	id: z.string(),
+	nodeClass: z.string(),
+	params: aiParamsSchema
+});
+const bridgeStateTreeTransitionReportSchema = z.object({
+	eventTag: z.string().optional(),
+	id: z.string(),
+	targetStateName: z.string().optional(),
+	targetType: z.string(),
+	trigger: z.string()
+});
+const bridgeStateTreeParameterReportSchema = z.object({
+	name: z.string(),
+	type: z.string(),
+	value: z.string()
+});
+const bridgeStateTreeStateReportSchema = z.object({
+	considerations: z.array(bridgeStateTreeNodeReportSchema).max(8),
+	utilityWeight: z.number(),
+	enterConditions: z.array(bridgeStateTreeNodeReportSchema).max(8),
+	id: z.string(),
+	linkedAssetPath: z.string().optional(),
+	linkedStateName: z.string().optional(),
+	name: z.string(),
+	parameters: z.array(bridgeStateTreeParameterReportSchema).max(16),
+	parametersId: z.string().optional(),
+	parentId: z.string().optional(),
+	selectionBehavior: z.string(),
+	stateType: z.string(),
+	tasks: z.array(bridgeStateTreeNodeReportSchema).max(8),
+	transitions: z.array(bridgeStateTreeTransitionReportSchema).max(8)
+});
+const bridgeStateTreeBindingReportSchema = z.object({
+	sourcePath: z.string(),
+	sourceStructId: z.string(),
+	targetPath: z.string(),
+	targetStructId: z.string()
+});
+const bridgeGetStateTreeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	bindings: z.array(bridgeStateTreeBindingReportSchema).max(128),
+	compiled: z.boolean(),
+	evaluators: z.array(bridgeStateTreeNodeReportSchema).max(16),
+	globalTasks: z.array(bridgeStateTreeNodeReportSchema).max(16),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	parameters: z.array(bridgeStateTreeParameterReportSchema).max(16),
+	parametersId: z.string().optional(),
 	requestId: requestIdSchema,
-	tickResolution: bridgeSequenceFrameRateSchema.optional(),
-	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE),
+	schemaClass: z.string(),
+	state: aiReportStateSchema,
+	stateCount: z.number().int().min(0),
+	states: z.array(bridgeStateTreeStateReportSchema).max(128),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_STATE_TREE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeSequenceBindingSchema = z.object({
-	actorPath: actorPathSchema.optional(),
-	bindingKind: sequenceBindingKindSchema,
-	name: boundedStringSchema.optional(),
-	objectClassPath: assetPathSchema.optional()
-}).superRefine((binding, ctx) => {
-	if (binding.bindingKind === "possessable" && binding.actorPath === void 0) {
-		ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			message: "A possessable binding must name the actorPath it possesses.",
-			path: ["actorPath"]
-		});
-		return;
-	}
-	if (binding.bindingKind === "spawnable" && binding.actorPath === void 0 && binding.objectClassPath === void 0) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: "A spawnable binding needs a template, so it must carry actorPath or objectClassPath.",
-		path: ["objectClassPath"]
-	});
+const bridgeStateTreeGlobalNodeSchema = z.object({
+	kind: stateTreeGlobalKindSchema,
+	nodeClass: assetPathSchema,
+	params: eqsParamsSchema.default({})
 });
-const bridgeAddSequenceBindingRequestSchema = z.object({
+const bridgeSetStateTreeGlobalsRequestSchema = z.object({
 	assetPath: assetPathSchema,
-	bindings: z.array(bridgeSequenceBindingSchema).min(1).max(32),
+	compile: z.boolean().default(true),
+	mode: stateTreeGlobalModeSchema.default("merge"),
+	nodes: z.array(bridgeStateTreeGlobalNodeSchema).max(16).default([]),
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE),
+	type: z.literal(BRIDGE_SET_STATE_TREE_GLOBALS_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeAddSequenceTrackRequestFieldsSchema = z.object({
+const bridgeSetStateTreeGlobalsSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	compileMessages: z.array(z.string()).max(25),
+	compiled: z.boolean(),
+	evaluatorCount: z.number().int().min(0),
+	globalTaskCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_SET_STATE_TREE_GLOBALS_REQUEST_TYPE)
+});
+const bridgeStateTreeConsiderationSchema = z.object({
+	nodeClass: assetPathSchema,
+	params: eqsParamsSchema.default({})
+});
+const bridgeStateTreeConsiderationTargetSchema = z.object({
+	considerations: z.array(bridgeStateTreeConsiderationSchema).max(8).default([]),
+	selectionBehavior: stateTreeSelectionBehaviorSchema.optional(),
+	stateName: userTypeIdentifierSchema,
+	weight: z.number().min(0).max(1e3).default(1)
+});
+const bridgeSetStateTreeConsiderationsRequestSchema = z.object({
 	assetPath: assetPathSchema,
-	bindingId: sequenceBindingIdSchema.optional(),
-	propertyPath: propertyPathSchema.optional(),
+	compile: z.boolean().default(true),
 	requestId: requestIdSchema,
-	sectionEndFrame: sequenceFrameSchema.optional(),
-	sectionStartFrame: sequenceFrameSchema.optional(),
-	trackKind: sequenceTrackKindSchema,
-	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	states: z.array(bridgeStateTreeConsiderationTargetSchema).min(1).max(32),
+	type: z.literal(BRIDGE_SET_STATE_TREE_CONSIDERATIONS_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeAddSequenceTrackRequestSchema = bridgeAddSequenceTrackRequestFieldsSchema.superRefine((request, ctx) => {
-	if (request.trackKind === "property" && request.propertyPath === void 0) ctx.addIssue({
-		code: z.ZodIssueCode.custom,
-		message: "A 'property' track must name the propertyPath it animates.",
-		path: ["propertyPath"]
-	});
-	if (request.trackKind !== "camera_cut" && request.bindingId === void 0) ctx.addIssue({
+const bridgeSetStateTreeConsiderationsSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	compileMessages: z.array(z.string()).max(25),
+	compiled: z.boolean(),
+	supported: z.boolean(),
+	supportedVersions: z.array(z.string()).max(16),
+	type: z.literal(BRIDGE_SET_STATE_TREE_CONSIDERATIONS_REQUEST_TYPE)
+});
+const bridgeStateTreeLinkSchema = z.object({
+	linkType: stateTreeLinkTypeSchema,
+	linkedAssetPath: assetPathSchema.optional(),
+	parameterOverrides: eqsParamsSchema.default({}),
+	stateName: userTypeIdentifierSchema,
+	targetStateName: userTypeIdentifierSchema.optional()
+}).superRefine((link, ctx) => {
+	if (link.linkType === "linked_asset" && link.linkedAssetPath === void 0) ctx.addIssue({
 		code: z.ZodIssueCode.custom,
-		message: `A '${request.trackKind}' track belongs to a binding, so bindingId is required.`,
-		path: ["bindingId"]
+		message: "A 'linked_asset' link must name its linkedAssetPath.",
+		path: ["linkedAssetPath"]
 	});
-	if (request.sectionStartFrame !== void 0 && request.sectionEndFrame !== void 0 && request.sectionEndFrame < request.sectionStartFrame) ctx.addIssue({
+	if (link.linkType === "linked_state" && link.targetStateName === void 0) ctx.addIssue({
 		code: z.ZodIssueCode.custom,
-		message: "A section cannot end before it starts.",
-		path: ["sectionEndFrame"]
+		message: "A 'linked_state' link must name its targetStateName.",
+		path: ["targetStateName"]
 	});
 });
-const bridgeSequenceKeySchema = z.object({
-	arriveTangent: z.number().optional(),
-	interpolation: sequenceInterpolationSchema.default("auto"),
-	leaveTangent: z.number().optional(),
-	time: z.number(),
-	value: z.number()
-});
-const bridgeAddSequenceKeysRequestSchema = z.object({
+const bridgeLinkStateTreeStateRequestSchema = z.object({
 	assetPath: assetPathSchema,
-	bindingId: sequenceBindingIdSchema.optional(),
-	channelName: boundedStringSchema,
-	keys: z.array(bridgeSequenceKeySchema).min(1).max(128),
+	compile: z.boolean().default(true),
+	links: z.array(bridgeStateTreeLinkSchema).min(1).max(16),
 	requestId: requestIdSchema,
-	timeUnit: sequenceTimeUnitSchema,
-	trackName: boundedStringSchema,
-	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	type: z.literal(BRIDGE_LINK_STATE_TREE_STATE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeCreateLevelSequenceSuccessResponseSchema = z.object({
-	...createdUserAssetResponseFields,
-	displayRate: bridgeSequenceFrameRateSchema,
-	durationInFrames: z.number().int().min(0),
-	tickResolution: bridgeSequenceFrameRateSchema,
-	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE)
-});
-const bridgeAddSequenceBindingSuccessResponseSchema = z.object({
+const bridgeLinkStateTreeStateSuccessResponseSchema = z.object({
 	...authoringBatchResponseFields,
-	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE)
+	compileMessages: z.array(z.string()).max(25),
+	compiled: z.boolean(),
+	type: z.literal(BRIDGE_LINK_STATE_TREE_STATE_REQUEST_TYPE)
 });
-const bridgeAddSequenceTrackSuccessResponseSchema = z.object({
-	assetPath: z.string(),
+const bridgeAddStateTreeComponentRequestSchema = z.object({
+	blueprintPath: assetPathSchema,
+	componentKind: stateTreeComponentKindSchema.default("state_tree"),
+	componentName: userTypeIdentifierSchema.optional(),
+	requestId: requestIdSchema,
+	startLogicAutomatically: z.boolean().default(true),
+	stateTreePath: assetPathSchema,
+	type: z.literal(BRIDGE_ADD_STATE_TREE_COMPONENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddStateTreeComponentSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	componentClass: z.string(),
+	componentName: z.string(),
 	message: nonEmptyStringSchema.optional(),
 	ok: z.literal(true),
 	packageDirty: z.boolean(),
 	requestId: requestIdSchema,
-	sectionIndex: z.number().int().min(0),
-	state: creativeEditStateSchema,
-	trackKind: sequenceTrackKindSchema,
-	trackName: z.string(),
-	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	schemaClass: z.string(),
+	state: aiReportStateSchema,
+	type: z.literal(BRIDGE_ADD_STATE_TREE_COMPONENT_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeAddSequenceKeysSuccessResponseSchema = z.object({
-	assetPath: z.string(),
-	channelName: z.string(),
-	keyCount: z.number().int().min(0),
+const bridgeTraceStateTreeRequestSchema = z.object({
+	action: stateTreeTraceActionSchema,
+	actorPath: assetPathSchema.optional(),
+	maxEvents: z.number().int().min(1).max(200).default(50),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStateTreeTraceEventSchema = z.object({
+	detail: z.string().optional(),
+	kind: stateTreeTraceKindSchema,
+	stateName: z.string().optional(),
+	timestampSeconds: z.number().min(0)
+});
+const bridgeTraceStateTreeSuccessResponseSchema = z.object({
+	action: stateTreeTraceActionSchema,
+	droppedCount: z.number().int().min(0),
+	eventCount: z.number().int().min(0),
+	events: z.array(bridgeStateTreeTraceEventSchema).max(200),
 	message: nonEmptyStringSchema.optional(),
 	ok: z.literal(true),
-	packageDirty: z.boolean(),
+	recording: z.boolean(),
 	requestId: requestIdSchema,
-	resolvedFrames: z.array(z.number().int()).max(128),
-	state: creativeEditStateSchema,
-	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	state: aiRuntimeStateSchema,
+	type: z.literal(BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeCreateLevelSequenceResponseSchema = z.union([bridgeCreateLevelSequenceSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeAddSequenceBindingResponseSchema = z.union([bridgeAddSequenceBindingSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeAddSequenceTrackResponseSchema = z.union([bridgeAddSequenceTrackSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeAddSequenceKeysResponseSchema = z.union([bridgeAddSequenceKeysSuccessResponseSchema, bridgeErrorResponseSchema]);
-function createBridgeCreateLevelSequenceRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
-	return bridgeCreateLevelSequenceRequestSchema.parse({
-		assetName,
-		displayRate: options.displayRate,
-		durationInFrames: options.durationInFrames,
-		packagePath,
+const bridgeGetStateTreeResponseSchema = z.union([bridgeGetStateTreeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetStateTreeGlobalsResponseSchema = z.union([bridgeSetStateTreeGlobalsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetStateTreeConsiderationsResponseSchema = z.union([bridgeSetStateTreeConsiderationsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeLinkStateTreeStateResponseSchema = z.union([bridgeLinkStateTreeStateSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddStateTreeComponentResponseSchema = z.union([bridgeAddStateTreeComponentSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeTraceStateTreeResponseSchema = z.union([bridgeTraceStateTreeSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeGetStateTreeRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetStateTreeRequestSchema.parse({
+		assetPath,
 		requestId,
-		tickResolution: options.tickResolution,
-		type: BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE,
+		type: BRIDGE_GET_STATE_TREE_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeAddSequenceBindingRequest(assetPath, bindings, requestId = randomUUID()) {
-	return bridgeAddSequenceBindingRequestSchema.parse({
+function createBridgeSetStateTreeGlobalsRequest(assetPath, nodes, options = {}, requestId = randomUUID()) {
+	return bridgeSetStateTreeGlobalsRequestSchema.parse({
 		assetPath,
-		bindings,
+		compile: options.compile,
+		mode: options.mode,
+		nodes,
 		requestId,
-		type: BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE,
+		type: BRIDGE_SET_STATE_TREE_GLOBALS_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeAddSequenceTrackRequest(assetPath, trackKind, options = {}, requestId = randomUUID()) {
-	return bridgeAddSequenceTrackRequestSchema.parse({
+function createBridgeSetStateTreeConsiderationsRequest(assetPath, states, options = {}, requestId = randomUUID()) {
+	return bridgeSetStateTreeConsiderationsRequestSchema.parse({
 		assetPath,
-		bindingId: options.bindingId,
-		propertyPath: options.propertyPath,
+		compile: options.compile,
 		requestId,
-		sectionEndFrame: options.sectionEndFrame,
-		sectionStartFrame: options.sectionStartFrame,
-		trackKind,
-		type: BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE,
+		states,
+		type: BRIDGE_SET_STATE_TREE_CONSIDERATIONS_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeAddSequenceKeysRequest(assetPath, trackName, channelName, timeUnit, keys, options = {}, requestId = randomUUID()) {
-	return bridgeAddSequenceKeysRequestSchema.parse({
+function createBridgeLinkStateTreeStateRequest(assetPath, links, options = {}, requestId = randomUUID()) {
+	return bridgeLinkStateTreeStateRequestSchema.parse({
 		assetPath,
-		bindingId: options.bindingId,
-		channelName,
-		keys,
+		compile: options.compile,
+		links,
 		requestId,
-		timeUnit,
-		trackName,
-		type: BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE,
+		type: BRIDGE_LINK_STATE_TREE_STATE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddStateTreeComponentRequest(blueprintPath, stateTreePath, options = {}, requestId = randomUUID()) {
+	return bridgeAddStateTreeComponentRequestSchema.parse({
+		blueprintPath,
+		componentKind: options.componentKind,
+		componentName: options.componentName,
+		requestId,
+		startLogicAutomatically: options.startLogicAutomatically,
+		stateTreePath,
+		type: BRIDGE_ADD_STATE_TREE_COMPONENT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeTraceStateTreeRequest(action, options = {}, requestId = randomUUID()) {
+	return bridgeTraceStateTreeRequestSchema.parse({
+		action,
+		actorPath: options.actorPath,
+		maxEvents: options.maxEvents,
+		requestId,
+		type: BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE,
 		version: 2
 	});
 }
 //#endregion
-//#region src/protocol/foliage.ts
-const BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE = "add_foliage_type";
-const BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE = "paint_foliage";
-const BRIDGE_FOLIAGE_PLACEMENT_MODES = ["explicit", "region"];
-const BRIDGE_FOLIAGE_MAX_DENSITY = 1e3;
-const BRIDGE_FOLIAGE_COORDINATE_LIMIT = 21e6;
-const BRIDGE_FOLIAGE_MAX_SCALE = 1e3;
-const foliagePlacementModeSchema = z.enum(BRIDGE_FOLIAGE_PLACEMENT_MODES);
-const foliageCoordinateSchema = z.number().min(-21e6).max(BRIDGE_FOLIAGE_COORDINATE_LIMIT);
-const foliageSlopeSchema = z.number().min(0).max(90);
-const bridgeFoliageSettingsSchema = z.object({
-	alignToNormal: z.boolean().optional(),
-	collisionEnabled: z.boolean().optional(),
-	density: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_DENSITY).optional(),
-	groundSlopeMax: foliageSlopeSchema.optional(),
-	groundSlopeMin: foliageSlopeSchema.optional(),
-	randomYaw: z.boolean().optional(),
-	scaleMax: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_SCALE).optional(),
+//#region src/protocol/perception.ts
+const BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE = "create_ai_controller";
+const BRIDGE_CONFIGURE_AI_PERCEPTION_REQUEST_TYPE = "configure_ai_perception";
+const BRIDGE_ADD_STIMULI_SOURCE_REQUEST_TYPE = "add_stimuli_source";
+const BRIDGE_AI_BRAIN_KINDS = [
+	"behavior_tree",
+	"state_tree",
+	"none"
+];
+const BRIDGE_AI_AUTO_POSSESS_MODES = [
+	"disabled",
+	"placed_in_world",
+	"spawned",
+	"placed_in_world_or_spawned"
+];
+const BRIDGE_AI_SENSE_KINDS = [
+	"sight",
+	"hearing",
+	"damage",
+	"team",
+	"touch",
+	"prediction"
+];
+const BRIDGE_AI_SENSE_MODES = ["set", "remove"];
+const aiBrainKindSchema = z.enum(BRIDGE_AI_BRAIN_KINDS);
+const aiAutoPossessModeSchema = z.enum(BRIDGE_AI_AUTO_POSSESS_MODES);
+const aiSenseKindSchema = z.enum(BRIDGE_AI_SENSE_KINDS);
+const aiSenseModeSchema = z.enum(BRIDGE_AI_SENSE_MODES);
+const bridgeCreateAiControllerRequestFieldsSchema = z.object({
+	addPerception: z.boolean().default(false),
+	assetName: assetNameSchema,
+	autoPossess: aiAutoPossessModeSchema.default("placed_in_world_or_spawned"),
+	behaviorTreePath: assetPathSchema.optional(),
+	blackboardPath: assetPathSchema.optional(),
+	brainKind: aiBrainKindSchema.default("behavior_tree"),
+	packagePath: contentPathSchema,
+	parentClass: assetPathSchema.optional(),
+	pawnClassPath: assetPathSchema.optional(),
+	requestId: requestIdSchema,
+	stateTreePath: assetPathSchema.optional(),
+	type: z.literal(BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateAiControllerRequestSchema = bridgeCreateAiControllerRequestFieldsSchema.superRefine((request, ctx) => {
+	if (request.brainKind === "behavior_tree" && request.behaviorTreePath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'behavior_tree' brain must name its behaviorTreePath.",
+		path: ["behaviorTreePath"]
+	});
+	if (request.brainKind === "state_tree" && request.stateTreePath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'state_tree' brain must name its stateTreePath.",
+		path: ["stateTreePath"]
+	});
+});
+const bridgeCreateAiControllerSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	autoPossess: z.string(),
+	brainKind: aiBrainKindSchema,
+	pawnClassPath: z.string().optional(),
+	perceptionAdded: z.boolean(),
+	type: z.literal(BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE),
+	warnings: z.array(z.string()).max(16)
+});
+const bridgeAiSenseConfigSchema = z.object({
+	detectEnemies: z.boolean().default(true),
+	detectFriendlies: z.boolean().default(false),
+	detectNeutrals: z.boolean().default(false),
+	mode: aiSenseModeSchema.default("set"),
+	params: eqsParamsSchema.default({}),
+	senseKind: aiSenseKindSchema
+});
+const bridgeConfigureAiPerceptionRequestSchema = z.object({
+	blueprintPath: assetPathSchema,
+	componentName: userTypeIdentifierSchema.optional(),
+	dominantSense: aiSenseKindSchema.optional(),
+	requestId: requestIdSchema,
+	senses: z.array(bridgeAiSenseConfigSchema).min(1).max(8),
+	type: z.literal(BRIDGE_CONFIGURE_AI_PERCEPTION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeConfigureAiPerceptionSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	componentName: z.string(),
+	senseCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CONFIGURE_AI_PERCEPTION_REQUEST_TYPE)
+});
+const bridgeAddStimuliSourceRequestSchema = z.object({
+	autoRegisterAsSource: z.boolean().default(true),
+	blueprintPath: assetPathSchema,
+	componentName: userTypeIdentifierSchema.optional(),
+	requestId: requestIdSchema,
+	senses: z.array(aiSenseKindSchema).min(1).max(8),
+	type: z.literal(BRIDGE_ADD_STIMULI_SOURCE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddStimuliSourceSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	componentName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	registeredSenses: z.array(z.string()).max(8),
+	requestId: requestIdSchema,
+	state: aiReportStateSchema,
+	type: z.literal(BRIDGE_ADD_STIMULI_SOURCE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateAiControllerResponseSchema = z.union([bridgeCreateAiControllerSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeConfigureAiPerceptionResponseSchema = z.union([bridgeConfigureAiPerceptionSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddStimuliSourceResponseSchema = z.union([bridgeAddStimuliSourceSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCreateAiControllerRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateAiControllerRequestSchema.parse({
+		addPerception: options.addPerception,
+		assetName,
+		autoPossess: options.autoPossess,
+		behaviorTreePath: options.behaviorTreePath,
+		blackboardPath: options.blackboardPath,
+		brainKind: options.brainKind,
+		packagePath,
+		parentClass: options.parentClass,
+		pawnClassPath: options.pawnClassPath,
+		requestId,
+		stateTreePath: options.stateTreePath,
+		type: BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeConfigureAiPerceptionRequest(blueprintPath, senses, options = {}, requestId = randomUUID()) {
+	return bridgeConfigureAiPerceptionRequestSchema.parse({
+		blueprintPath,
+		componentName: options.componentName,
+		dominantSense: options.dominantSense,
+		requestId,
+		senses,
+		type: BRIDGE_CONFIGURE_AI_PERCEPTION_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddStimuliSourceRequest(blueprintPath, senses, options = {}, requestId = randomUUID()) {
+	return bridgeAddStimuliSourceRequestSchema.parse({
+		autoRegisterAsSource: options.autoRegisterAsSource,
+		blueprintPath,
+		componentName: options.componentName,
+		requestId,
+		senses,
+		type: BRIDGE_ADD_STIMULI_SOURCE_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/eqs.ts
+const eqsTestPurposeSchema = z.enum(BRIDGE_EQS_TEST_PURPOSES);
+const BRIDGE_GET_EQS_QUERY_REQUEST_TYPE = "get_eqs_query";
+const BRIDGE_EDIT_EQS_QUERY_REQUEST_TYPE = "edit_eqs_query";
+const BRIDGE_RUN_EQS_QUERY_REQUEST_TYPE = "run_eqs_query";
+const BRIDGE_EQS_RUN_MODES = [
+	"single_result",
+	"random_best_25_percent",
+	"random_best_5_percent",
+	"all_matching"
+];
+const BRIDGE_EQS_TEST_OPERATIONS = [
+	"add",
+	"update",
+	"remove",
+	"move"
+];
+const eqsRunModeSchema = z.enum(BRIDGE_EQS_RUN_MODES);
+const eqsTestOperationSchema = z.enum(BRIDGE_EQS_TEST_OPERATIONS);
+const bridgeGetEqsQueryRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEqsTestReportSchema = z.object({
+	params: aiParamsSchema,
+	purpose: z.string(),
+	testClass: z.string(),
+	testIndex: z.number().int().min(0)
+});
+const bridgeEqsOptionReportSchema = z.object({
+	generatorClass: z.string(),
+	generatorParams: aiParamsSchema,
+	optionIndex: z.number().int().min(0),
+	tests: z.array(bridgeEqsTestReportSchema).max(16)
+});
+const bridgeGetEqsQuerySuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	eqsEnabled: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	options: z.array(bridgeEqsOptionReportSchema).max(8),
+	requestId: requestIdSchema,
+	state: aiReportStateSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEqsTestEditSchema = z.object({
+	operation: eqsTestOperationSchema,
+	params: eqsParamsSchema.default({}),
+	purpose: eqsTestPurposeSchema.optional(),
+	testClass: assetPathSchema.optional(),
+	testIndex: z.number().int().min(0).max(15).optional(),
+	toIndex: z.number().int().min(0).max(16).optional()
+}).superRefine((edit, ctx) => {
+	if (edit.operation === "add" && edit.testClass === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "An 'add' test edit must name its testClass.",
+		path: ["testClass"]
+	});
+	if (edit.operation !== "add" && edit.testIndex === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A '${edit.operation}' test edit must name the testIndex it addresses.`,
+		path: ["testIndex"]
+	});
+	if (edit.operation === "move" && edit.toIndex === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'move' test edit must name its toIndex.",
+		path: ["toIndex"]
+	});
+});
+const bridgeEditEqsQueryRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	generatorClass: assetPathSchema.optional(),
+	generatorParams: eqsParamsSchema.optional(),
+	optionIndex: z.number().int().min(0).max(7).default(0),
+	requestId: requestIdSchema,
+	tests: z.array(bridgeEqsTestEditSchema).max(16).default([]),
+	type: z.literal(BRIDGE_EDIT_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEditEqsQuerySuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	generatorClass: z.string(),
+	testCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_EDIT_EQS_QUERY_REQUEST_TYPE)
+});
+const bridgeRunEqsQueryRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	maxItems: z.number().int().min(1).max(64).default(25),
+	querierActorPath: assetPathSchema.optional(),
+	querierLocation: bridgeVectorSchema.optional(),
+	requestId: requestIdSchema,
+	runMode: eqsRunModeSchema.default("all_matching"),
+	type: z.literal(BRIDGE_RUN_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRunEqsQueryRequestSchema = bridgeRunEqsQueryRequestFieldsSchema.refine((request) => request.querierActorPath !== void 0 || request.querierLocation !== void 0, {
+	message: "A run_eqs_query request must name either a querierActorPath or a querierLocation.",
+	path: ["querierActorPath"]
+});
+const bridgeEqsItemTestScoreSchema = z.object({
+	score: z.number(),
+	testClass: z.string(),
+	testIndex: z.number().int().min(0)
+});
+const bridgeEqsResultItemSchema = z.object({
+	actorPath: z.string().optional(),
+	index: z.number().int().min(0),
+	location: bridgeVectorSchema,
+	score: z.number(),
+	testScores: z.array(bridgeEqsItemTestScoreSchema).max(16)
+});
+const bridgeRunEqsQuerySuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	itemCount: z.number().int().min(0),
+	items: z.array(bridgeEqsResultItemSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	runMode: eqsRunModeSchema,
+	state: aiReportStateSchema,
+	type: z.literal(BRIDGE_RUN_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2),
+	winningItemIndex: z.number().int().min(0).optional()
+});
+const bridgeGetEqsQueryResponseSchema = z.union([bridgeGetEqsQuerySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeEditEqsQueryResponseSchema = z.union([bridgeEditEqsQuerySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRunEqsQueryResponseSchema = z.union([bridgeRunEqsQuerySuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeGetEqsQueryRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetEqsQueryRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_GET_EQS_QUERY_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeEditEqsQueryRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeEditEqsQueryRequestSchema.parse({
+		assetPath,
+		generatorClass: options.generatorClass,
+		generatorParams: options.generatorParams,
+		optionIndex: options.optionIndex,
+		requestId,
+		tests: options.tests,
+		type: BRIDGE_EDIT_EQS_QUERY_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRunEqsQueryRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeRunEqsQueryRequestSchema.parse({
+		assetPath,
+		maxItems: options.maxItems,
+		querierActorPath: options.querierActorPath,
+		querierLocation: options.querierLocation,
+		requestId,
+		runMode: options.runMode,
+		type: BRIDGE_RUN_EQS_QUERY_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/sequencer.ts
+const BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE = "create_level_sequence";
+const BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE = "add_sequence_binding";
+const BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE = "add_sequence_track";
+const BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE = "add_sequence_keys";
+const BRIDGE_SEQUENCE_BINDING_KINDS = ["possessable", "spawnable"];
+const BRIDGE_SEQUENCE_TRACK_KINDS = [
+	"transform",
+	"skeletal_animation",
+	"camera_cut",
+	"audio",
+	"visibility",
+	"property"
+];
+const BRIDGE_SEQUENCE_TIME_UNITS = ["frames", "seconds"];
+const BRIDGE_SEQUENCE_INTERPOLATIONS = [
+	"auto",
+	"user",
+	"break",
+	"linear",
+	"constant"
+];
+const BRIDGE_SEQUENCE_MAX_FRAME_RATE = 24e4;
+const BRIDGE_SEQUENCE_MAX_FRAME = 1e7;
+const sequenceBindingKindSchema = z.enum(BRIDGE_SEQUENCE_BINDING_KINDS);
+const sequenceTrackKindSchema = z.enum(BRIDGE_SEQUENCE_TRACK_KINDS);
+const sequenceTimeUnitSchema = z.enum(BRIDGE_SEQUENCE_TIME_UNITS);
+const sequenceInterpolationSchema = z.enum(BRIDGE_SEQUENCE_INTERPOLATIONS);
+const sequenceBindingIdSchema = z.string().trim().min(1).max(64);
+const sequenceFrameSchema = z.number().int().min(-1e7).max(BRIDGE_SEQUENCE_MAX_FRAME);
+const bridgeSequenceFrameRateSchema = z.object({
+	denominator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE),
+	numerator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE)
+});
+const bridgeCreateLevelSequenceRequestSchema = z.object({
+	assetName: assetNameSchema,
+	displayRate: bridgeSequenceFrameRateSchema.optional(),
+	durationInFrames: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME).optional(),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	tickResolution: bridgeSequenceFrameRateSchema.optional(),
+	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSequenceBindingSchema = z.object({
+	actorPath: actorPathSchema.optional(),
+	bindingKind: sequenceBindingKindSchema,
+	name: boundedStringSchema.optional(),
+	objectClassPath: assetPathSchema.optional()
+}).superRefine((binding, ctx) => {
+	if (binding.bindingKind === "possessable" && binding.actorPath === void 0) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "A possessable binding must name the actorPath it possesses.",
+			path: ["actorPath"]
+		});
+		return;
+	}
+	if (binding.bindingKind === "spawnable" && binding.actorPath === void 0 && binding.objectClassPath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A spawnable binding needs a template, so it must carry actorPath or objectClassPath.",
+		path: ["objectClassPath"]
+	});
+});
+const bridgeAddSequenceBindingRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	bindings: z.array(bridgeSequenceBindingSchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceTrackRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	bindingId: sequenceBindingIdSchema.optional(),
+	propertyPath: propertyPathSchema.optional(),
+	requestId: requestIdSchema,
+	sectionEndFrame: sequenceFrameSchema.optional(),
+	sectionStartFrame: sequenceFrameSchema.optional(),
+	trackKind: sequenceTrackKindSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceTrackRequestSchema = bridgeAddSequenceTrackRequestFieldsSchema.superRefine((request, ctx) => {
+	if (request.trackKind === "property" && request.propertyPath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'property' track must name the propertyPath it animates.",
+		path: ["propertyPath"]
+	});
+	if (request.trackKind !== "camera_cut" && request.bindingId === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A '${request.trackKind}' track belongs to a binding, so bindingId is required.`,
+		path: ["bindingId"]
+	});
+	if (request.sectionStartFrame !== void 0 && request.sectionEndFrame !== void 0 && request.sectionEndFrame < request.sectionStartFrame) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A section cannot end before it starts.",
+		path: ["sectionEndFrame"]
+	});
+});
+const bridgeSequenceKeySchema = z.object({
+	arriveTangent: z.number().optional(),
+	interpolation: sequenceInterpolationSchema.default("auto"),
+	leaveTangent: z.number().optional(),
+	time: z.number(),
+	value: z.number()
+});
+const bridgeAddSequenceKeysRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	bindingId: sequenceBindingIdSchema.optional(),
+	channelName: boundedStringSchema,
+	keys: z.array(bridgeSequenceKeySchema).min(1).max(128),
+	requestId: requestIdSchema,
+	timeUnit: sequenceTimeUnitSchema,
+	trackName: boundedStringSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateLevelSequenceSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	displayRate: bridgeSequenceFrameRateSchema,
+	durationInFrames: z.number().int().min(0),
+	tickResolution: bridgeSequenceFrameRateSchema,
+	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE)
+});
+const bridgeAddSequenceBindingSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE)
+});
+const bridgeAddSequenceTrackSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	sectionIndex: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	trackKind: sequenceTrackKindSchema,
+	trackName: z.string(),
+	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceKeysSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	channelName: z.string(),
+	keyCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	resolvedFrames: z.array(z.number().int()).max(128),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateLevelSequenceResponseSchema = z.union([bridgeCreateLevelSequenceSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceBindingResponseSchema = z.union([bridgeAddSequenceBindingSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceTrackResponseSchema = z.union([bridgeAddSequenceTrackSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceKeysResponseSchema = z.union([bridgeAddSequenceKeysSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCreateLevelSequenceRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateLevelSequenceRequestSchema.parse({
+		assetName,
+		displayRate: options.displayRate,
+		durationInFrames: options.durationInFrames,
+		packagePath,
+		requestId,
+		tickResolution: options.tickResolution,
+		type: BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceBindingRequest(assetPath, bindings, requestId = randomUUID()) {
+	return bridgeAddSequenceBindingRequestSchema.parse({
+		assetPath,
+		bindings,
+		requestId,
+		type: BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceTrackRequest(assetPath, trackKind, options = {}, requestId = randomUUID()) {
+	return bridgeAddSequenceTrackRequestSchema.parse({
+		assetPath,
+		bindingId: options.bindingId,
+		propertyPath: options.propertyPath,
+		requestId,
+		sectionEndFrame: options.sectionEndFrame,
+		sectionStartFrame: options.sectionStartFrame,
+		trackKind,
+		type: BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceKeysRequest(assetPath, trackName, channelName, timeUnit, keys, options = {}, requestId = randomUUID()) {
+	return bridgeAddSequenceKeysRequestSchema.parse({
+		assetPath,
+		bindingId: options.bindingId,
+		channelName,
+		keys,
+		requestId,
+		timeUnit,
+		trackName,
+		type: BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/foliage.ts
+const BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE = "add_foliage_type";
+const BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE = "paint_foliage";
+const BRIDGE_FOLIAGE_PLACEMENT_MODES = ["explicit", "region"];
+const BRIDGE_FOLIAGE_MAX_DENSITY = 1e3;
+const BRIDGE_FOLIAGE_COORDINATE_LIMIT = 21e6;
+const BRIDGE_FOLIAGE_MAX_SCALE = 1e3;
+const foliagePlacementModeSchema = z.enum(BRIDGE_FOLIAGE_PLACEMENT_MODES);
+const foliageCoordinateSchema = z.number().min(-21e6).max(BRIDGE_FOLIAGE_COORDINATE_LIMIT);
+const foliageSlopeSchema = z.number().min(0).max(90);
+const bridgeFoliageSettingsSchema = z.object({
+	alignToNormal: z.boolean().optional(),
+	collisionEnabled: z.boolean().optional(),
+	density: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_DENSITY).optional(),
+	groundSlopeMax: foliageSlopeSchema.optional(),
+	groundSlopeMin: foliageSlopeSchema.optional(),
+	randomYaw: z.boolean().optional(),
+	scaleMax: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_SCALE).optional(),
 	scaleMin: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_SCALE).optional()
 });
 const bridgeAddFoliageTypeRequestSchema = z.object({
@@ -8648,18 +9327,108 @@ function createBridgeAddBtNodeRequest(assetPath, nodes, requestId = randomUUID()
 function createBridgeAddBtDecoratorRequest(assetPath, decorators, requestId = randomUUID()) {
 	return bridgeAddBtDecoratorRequestSchema.parse({
 		assetPath,
-		decorators,
+		decorators,
+		requestId,
+		type: BRIDGE_ADD_BT_DECORATOR_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddBtServiceRequest(assetPath, services, requestId = randomUUID()) {
+	return bridgeAddBtServiceRequestSchema.parse({
+		assetPath,
+		requestId,
+		services,
+		type: BRIDGE_ADD_BT_SERVICE_REQUEST_TYPE,
+		version: 2
+	});
+}
+const BRIDGE_GET_BEHAVIOR_TREE_REQUEST_TYPE = "get_behavior_tree";
+const BRIDGE_GET_BT_RUNTIME_STATE_REQUEST_TYPE = "get_bt_runtime_state";
+const bridgeGetBehaviorTreeRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BEHAVIOR_TREE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBehaviorTreeSubNodeReportSchema = z.object({
+	blackboardKeys: z.array(z.string()).max(64),
+	name: z.string(),
+	nodeClass: z.string(),
+	nodeGuid: z.string(),
+	params: aiParamsSchema
+});
+const bridgeBehaviorTreeNodeReportSchema = z.object({
+	blackboardKeys: z.array(z.string()).max(64),
+	childIndex: z.number().int().min(0),
+	decorators: z.array(bridgeBehaviorTreeSubNodeReportSchema).max(200),
+	name: z.string(),
+	nodeClass: z.string(),
+	nodeGuid: z.string(),
+	nodeKind: z.string(),
+	params: aiParamsSchema,
+	parentNodeGuid: z.string().optional(),
+	services: z.array(bridgeBehaviorTreeSubNodeReportSchema).max(200)
+});
+const bridgeGetBehaviorTreeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	blackboardPath: z.string().optional(),
+	message: nonEmptyStringSchema.optional(),
+	nodeCount: z.number().int().min(0),
+	nodes: z.array(bridgeBehaviorTreeNodeReportSchema).max(200),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	rootNodeGuid: z.string().optional(),
+	state: aiReportStateSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_BEHAVIOR_TREE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetBtRuntimeStateRequestSchema = z.object({
+	actorPath: assetPathSchema.optional(),
+	maxAborts: z.number().int().min(0).max(25).default(25),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BT_RUNTIME_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBtBlackboardValueSchema = z.object({
+	keyName: z.string(),
+	keyType: z.string(),
+	value: z.string()
+});
+const bridgeBtAbortReportSchema = z.object({
+	decoratorName: z.string(),
+	nodeName: z.string(),
+	timestampSeconds: z.number().min(0)
+});
+const bridgeGetBtRuntimeStateSuccessResponseSchema = z.object({
+	activeNodePath: z.array(z.string()).max(32),
+	actorPath: z.string().optional(),
+	blackboard: z.array(bridgeBtBlackboardValueSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	recentAborts: z.array(bridgeBtAbortReportSchema).max(25),
+	requestId: requestIdSchema,
+	state: aiRuntimeStateSchema,
+	treePath: z.string().optional(),
+	type: z.literal(BRIDGE_GET_BT_RUNTIME_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetBehaviorTreeResponseSchema = z.union([bridgeGetBehaviorTreeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBtRuntimeStateResponseSchema = z.union([bridgeGetBtRuntimeStateSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeGetBehaviorTreeRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetBehaviorTreeRequestSchema.parse({
+		assetPath,
 		requestId,
-		type: BRIDGE_ADD_BT_DECORATOR_REQUEST_TYPE,
+		type: BRIDGE_GET_BEHAVIOR_TREE_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeAddBtServiceRequest(assetPath, services, requestId = randomUUID()) {
-	return bridgeAddBtServiceRequestSchema.parse({
-		assetPath,
+function createBridgeGetBtRuntimeStateRequest(options = {}, requestId = randomUUID()) {
+	return bridgeGetBtRuntimeStateRequestSchema.parse({
+		actorPath: options.actorPath,
+		maxAborts: options.maxAborts,
 		requestId,
-		services,
-		type: BRIDGE_ADD_BT_SERVICE_REQUEST_TYPE,
+		type: BRIDGE_GET_BT_RUNTIME_STATE_REQUEST_TYPE,
 		version: 2
 	});
 }
@@ -9715,7 +10484,7 @@ function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}
 }
 //#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.9.0";
+const SERVER_VERSION = "1.10.0";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -10605,6 +11374,48 @@ async function sendBridgeControlBlueprintDebuggerRequest(request, options) {
 async function sendBridgeWatchBlueprintPinRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeWatchBlueprintPinResponseSchema, request.requestId);
 }
+async function sendBridgeAddStateTreeComponentRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddStateTreeComponentResponseSchema, request.requestId);
+}
+async function sendBridgeAddStimuliSourceRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddStimuliSourceResponseSchema, request.requestId);
+}
+async function sendBridgeConfigureAiPerceptionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeConfigureAiPerceptionResponseSchema, request.requestId);
+}
+async function sendBridgeCreateAiControllerRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateAiControllerResponseSchema, request.requestId);
+}
+async function sendBridgeEditEqsQueryRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeEditEqsQueryResponseSchema, request.requestId);
+}
+async function sendBridgeGetBehaviorTreeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBehaviorTreeResponseSchema, request.requestId);
+}
+async function sendBridgeGetBtRuntimeStateRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBtRuntimeStateResponseSchema, request.requestId);
+}
+async function sendBridgeGetEqsQueryRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetEqsQueryResponseSchema, request.requestId);
+}
+async function sendBridgeGetStateTreeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetStateTreeResponseSchema, request.requestId);
+}
+async function sendBridgeLinkStateTreeStateRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeLinkStateTreeStateResponseSchema, request.requestId);
+}
+async function sendBridgeRunEqsQueryRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRunEqsQueryResponseSchema, request.requestId);
+}
+async function sendBridgeSetStateTreeConsiderationsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetStateTreeConsiderationsResponseSchema, request.requestId);
+}
+async function sendBridgeSetStateTreeGlobalsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetStateTreeGlobalsResponseSchema, request.requestId);
+}
+async function sendBridgeTraceStateTreeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeTraceStateTreeResponseSchema, request.requestId);
+}
 //#endregion
 //#region src/enginePing.ts
 async function pingRegistryEntry$1(entry, options) {
@@ -13677,6 +14488,24 @@ async function addBtDecorator(input, dependencies) {
 async function addBtService(input, dependencies) {
 	return await exchangeCreativeRequest(createBridgeAddBtServiceRequest(input.assetPath, input.services), sendBridgeAddBtServiceRequest, BRIDGE_ADD_BT_SERVICE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
 }
+const getBehaviorTreeInputSchema = {
+	assetPath: bridgeGetBehaviorTreeRequestSchema.shape.assetPath.describe("Object path of the Behavior Tree asset to read."),
+	projectId: creativeProjectIdSchema
+};
+const getBtRuntimeStateInputSchema = {
+	actorPath: bridgeGetBtRuntimeStateRequestSchema.shape.actorPath.describe("Actor in the PIE world to report on. Omitted reports the first AI found running a Behavior Tree."),
+	maxAborts: bridgeGetBtRuntimeStateRequestSchema.shape.maxAborts.describe("Maximum recent aborts to return (0-25, default 25)."),
+	projectId: creativeProjectIdSchema
+};
+async function getBehaviorTree(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetBehaviorTreeRequest(input.assetPath), sendBridgeGetBehaviorTreeRequest, BRIDGE_GET_BEHAVIOR_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getBtRuntimeState(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetBtRuntimeStateRequest({
+		actorPath: input.actorPath,
+		maxAborts: input.maxAborts
+	}), sendBridgeGetBtRuntimeStateRequest, BRIDGE_GET_BT_RUNTIME_STATE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
 function registerBehaviorTreeTools(server, dependencies) {
 	server.registerTool("create_behavior_tree", {
 		description: "Create a Behavior Tree asset and link its blackboard. Populate it with add_bt_node, then attach decorators and services. A tree with no blackboard has nothing for the stock decorators to key off.",
@@ -13723,6 +14552,27 @@ function registerBehaviorTreeTools(server, dependencies) {
 			services
 		}, dependencies));
 	});
+	server.registerTool("get_behavior_tree", {
+		description: "Read a Behavior Tree back: the node hierarchy with each node's GUID, class, child index, decorators, services, property values and the blackboard keys it reads. The GUIDs are the ones add_bt_decorator and add_bt_service address nodes by, so this is the call to make before editing a tree you did not author.",
+		inputSchema: getBehaviorTreeInputSchema,
+		title: "Get Behavior Tree"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getBehaviorTree({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_bt_runtime_state", {
+		description: "Report what an AI is actually doing in Play In Editor: the active node path from root to the running task, the live blackboard values, and recent aborts, each naming the decorator on the branch that was left whose observer could have caused it — the usual answer to a task that keeps stopping halfway. Aborts are sampled at 10 Hz rather than read from a real abort signal, so an entry is a node change under a branch carrying an observer abort, not a confirmed abort. Outside PIE the response comes back not_running rather than failing.",
+		inputSchema: getBtRuntimeStateInputSchema,
+		title: "Get Behavior Tree Runtime State"
+	}, async ({ actorPath, maxAborts, projectId }) => {
+		return toToolSuccess(await getBtRuntimeState({
+			actorPath,
+			maxAborts,
+			projectId
+		}, dependencies));
+	});
 }
 const behaviorTreeToolDomain = {
 	domain: "behaviorTree",
@@ -13731,7 +14581,9 @@ const behaviorTreeToolDomain = {
 		"create_behavior_tree",
 		"add_bt_node",
 		"add_bt_decorator",
-		"add_bt_service"
+		"add_bt_service",
+		"get_behavior_tree",
+		"get_bt_runtime_state"
 	]
 };
 const EXEC_PIN_NAMES = /* @__PURE__ */ new Set(["execute", "then"]);
@@ -14576,72 +15428,583 @@ async function collectGraphNodes(input, graphName, dependencies) {
 		};
 		cursor = response.nextNodeCursor;
 	}
-	return {
-		graphKind,
-		nodes,
-		truncated: true
-	};
+	return {
+		graphKind,
+		nodes,
+		truncated: true
+	};
+}
+async function exportBlueprintCpp(input, dependencies) {
+	const { summary, truncated: summaryTruncated } = await collectBlueprintSummary(input, dependencies);
+	const selected = input.graphName === void 0 ? summary.graphs.slice(0, input.maxGraphs) : summary.graphs.filter((graph) => graph.name === input.graphName);
+	if (input.graphName !== void 0 && selected.length === 0) throw new Error(`Blueprint '${summary.blueprintPath}' has no graph named '${input.graphName}'.`);
+	const rendered = [];
+	let truncated = summaryTruncated || input.graphName === void 0 && selected.length < summary.graphs.length;
+	for (const graph of selected) {
+		const { graphKind, nodes, truncated: graphTruncated } = await collectGraphNodes(input, graph.name, dependencies);
+		const pseudoCode = renderGraphPseudoCode({
+			graphKind,
+			graphName: graph.name,
+			nodes,
+			truncated: graphTruncated
+		});
+		truncated = truncated || pseudoCode.truncated;
+		rendered.push(pseudoCode);
+	}
+	const skeleton = renderCppSkeleton({
+		blueprintName: summary.blueprintName,
+		functions: summary.functions,
+		interfaces: summary.interfaces,
+		...summary.parentClass === void 0 ? {} : { parentClass: summary.parentClass },
+		variables: summary.variables
+	});
+	dependencies.logger.info({
+		blueprintPath: summary.blueprintPath,
+		graphCount: rendered.length,
+		projectId: summary.projectId
+	}, "Exported Blueprint graphs as pseudo-code");
+	return {
+		blueprintName: summary.blueprintName,
+		blueprintPath: summary.blueprintPath,
+		graphs: rendered,
+		projectId: summary.projectId,
+		pseudoCode: rendered.map((graph) => [`// ${graph.graphName} (${graph.graphKind})`, ...graph.lines].join("\n")).join("\n\n"),
+		skeleton,
+		truncated
+	};
+}
+const blueprintToolDomain = {
+	domain: "blueprint",
+	register: registerBlueprintTools,
+	toolNames: [
+		"find_blueprint_references",
+		"get_blueprint_summary",
+		"get_blueprint_graph",
+		"get_blueprint_compile_errors",
+		"compile_blueprint",
+		"get_blueprint_compile_status",
+		"create_blueprint",
+		"add_bp_variable",
+		"add_bp_function",
+		"add_bp_event",
+		"add_bp_component",
+		"add_bp_interface",
+		"set_bp_default",
+		"batch_edit",
+		"export_blueprint_cpp"
+	]
+};
+//#endregion
+//#region src/aiScaffold.ts
+const AI_NODE_KINDS = [
+	"state_tree_task",
+	"state_tree_condition",
+	"state_tree_evaluator",
+	"bt_task",
+	"bt_decorator",
+	"bt_service",
+	"eqs_generator",
+	"eqs_test"
+];
+const TEAM_AGENT_CLASS_KINDS = [
+	"controller",
+	"character",
+	"attitude_solver"
+];
+const CLASS_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+const CLASS_NAME_MAX_LENGTH = 96;
+const SUPPORTED_DESCRIPTOR_EXTENSIONS$1 = [".uproject", ".uplugin"];
+const NODE_KIND_DEPENDENCIES = {
+	bt_decorator: ["AIModule", "GameplayTasks"],
+	bt_service: ["AIModule", "GameplayTasks"],
+	bt_task: ["AIModule", "GameplayTasks"],
+	eqs_generator: ["AIModule", "GameplayTasks"],
+	eqs_test: ["AIModule", "GameplayTasks"],
+	state_tree_condition: ["StateTreeModule"],
+	state_tree_evaluator: ["StateTreeModule"],
+	state_tree_task: ["StateTreeModule"]
+};
+const TEAM_AGENT_DEPENDENCIES = ["AIModule", "GameplayTasks"];
+async function scaffoldAiNodeClass(input) {
+	const className = input.className.trim();
+	validateIdentifier(className, "Class name");
+	const moduleName = input.moduleName.trim();
+	validateIdentifier(moduleName, "Module name");
+	const descriptorPath = path.resolve(input.descriptorPath.trim());
+	validateDescriptorExtension$1(descriptorPath);
+	await assertModuleRegistered(descriptorPath, moduleName);
+	const moduleRoot = path.join(path.dirname(descriptorPath), "Source", moduleName);
+	await assertModuleRootExists(moduleRoot, moduleName);
+	const typeName = buildNodeTypeName(input.nodeKind, className);
+	const fileStem = typeName.startsWith("F") || typeName.startsWith("U") ? typeName.slice(1) : typeName;
+	const headerPath = path.join(moduleRoot, "Public", `${fileStem}.h`);
+	const sourcePath = path.join(moduleRoot, "Private", `${fileStem}.cpp`);
+	await assertFilesAbsent([headerPath, sourcePath]);
+	const displayName = (input.displayName ?? className).trim();
+	const apiMacro = `${moduleName.toUpperCase()}_API`;
+	const header = renderNodeHeader(input.nodeKind, typeName, fileStem, displayName, apiMacro);
+	const source = renderNodeSource(input.nodeKind, typeName, fileStem);
+	const createdFiles = await writeGeneratedFiles([{
+		contents: header,
+		filePath: headerPath
+	}, {
+		contents: source,
+		filePath: sourcePath
+	}]);
+	const requiredModuleDependencies = NODE_KIND_DEPENDENCIES[input.nodeKind];
+	const buildCsPath = path.join(moduleRoot, `${moduleName}.Build.cs`);
+	return {
+		buildCsPath,
+		buildCsUpdated: input.updateBuildCs === false ? false : await tryAddBuildDependencies(buildCsPath, requiredModuleDependencies),
+		createdFiles,
+		descriptorPath,
+		generatedTypes: [typeName],
+		moduleName,
+		moduleRoot,
+		requiredModuleDependencies
+	};
+}
+async function scaffoldTeamAgentClass(input) {
+	const classPrefix = input.classPrefix.trim();
+	validateIdentifier(classPrefix, "Class prefix");
+	const moduleName = input.moduleName.trim();
+	validateIdentifier(moduleName, "Module name");
+	if (input.classKinds.length === 0) throw new ModuleScaffoldError("At least one classKind must be requested.");
+	const defaultTeamId = input.defaultTeamId ?? 1;
+	if (!Number.isInteger(defaultTeamId) || defaultTeamId < 0 || defaultTeamId > 255) throw new ModuleScaffoldError(`Team id ${String(defaultTeamId)} is outside the 0-255 range FGenericTeamId holds.`);
+	const descriptorPath = path.resolve(input.descriptorPath.trim());
+	validateDescriptorExtension$1(descriptorPath);
+	await assertModuleRegistered(descriptorPath, moduleName);
+	const moduleRoot = path.join(path.dirname(descriptorPath), "Source", moduleName);
+	await assertModuleRootExists(moduleRoot, moduleName);
+	const apiMacro = `${moduleName.toUpperCase()}_API`;
+	const pending = [];
+	const generatedTypes = [];
+	for (const classKind of [...new Set(input.classKinds)]) {
+		const fileStem = buildTeamAgentFileStem(classKind, classPrefix);
+		const typeName = buildTeamAgentTypeName(classKind, classPrefix);
+		generatedTypes.push(typeName);
+		pending.push({
+			contents: renderTeamAgentHeader(classKind, classPrefix, fileStem, apiMacro, defaultTeamId),
+			filePath: path.join(moduleRoot, "Public", `${fileStem}.h`)
+		});
+		pending.push({
+			contents: renderTeamAgentSource(classKind, classPrefix, fileStem, defaultTeamId),
+			filePath: path.join(moduleRoot, "Private", `${fileStem}.cpp`)
+		});
+	}
+	await assertFilesAbsent(pending.map((file) => file.filePath));
+	const createdFiles = await writeGeneratedFiles(pending);
+	const buildCsPath = path.join(moduleRoot, `${moduleName}.Build.cs`);
+	return {
+		buildCsPath,
+		buildCsUpdated: input.updateBuildCs === false ? false : await tryAddBuildDependencies(buildCsPath, TEAM_AGENT_DEPENDENCIES),
+		createdFiles,
+		descriptorPath,
+		generatedTypes,
+		moduleName,
+		moduleRoot,
+		requiredModuleDependencies: TEAM_AGENT_DEPENDENCIES
+	};
+}
+function validateIdentifier(value, label) {
+	if (value.length === 0) throw new ModuleScaffoldError(`${label} cannot be empty.`);
+	if (value.length > CLASS_NAME_MAX_LENGTH) throw new ModuleScaffoldError(`${label} '${value}' exceeds ${String(CLASS_NAME_MAX_LENGTH)} characters.`);
+	if (!CLASS_NAME_PATTERN.test(value)) throw new ModuleScaffoldError(`${label} '${value}' must be a valid C++ identifier (letters, digits and underscores, starting with a letter).`);
+}
+function validateDescriptorExtension$1(descriptorPath) {
+	if (!SUPPORTED_DESCRIPTOR_EXTENSIONS$1.includes(path.extname(descriptorPath).toLowerCase())) throw new ModuleScaffoldError(`Descriptor path must end in .uproject or .uplugin, got '${descriptorPath}'.`);
+}
+async function assertModuleRegistered(descriptorPath, moduleName) {
+	let descriptorText;
+	try {
+		descriptorText = await readFile(descriptorPath, "utf8");
+	} catch (error) {
+		if (getErrorCode$1(error) === "ENOENT") throw new ModuleScaffoldError(`Descriptor not found at ${descriptorPath}.`);
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(descriptorText);
+	} catch (error) {
+		throw new ModuleScaffoldError(`Descriptor at ${descriptorPath} is not valid JSON.`, { cause: error });
+	}
+	const modules = isPlainObject$1(parsed) ? parsed.Modules : void 0;
+	if (!(Array.isArray(modules) && modules.some((entry) => isPlainObject$1(entry) && typeof entry.Name === "string" && entry.Name.toLowerCase() === moduleName.toLowerCase()))) throw new ModuleScaffoldError(`Module '${moduleName}' is not registered in ${descriptorPath}; add it with add_module first.`);
+}
+async function assertModuleRootExists(moduleRoot, moduleName) {
+	try {
+		await stat(moduleRoot);
+	} catch (error) {
+		if (getErrorCode$1(error) === "ENOENT") throw new ModuleScaffoldError(`Module source directory for '${moduleName}' was not found at ${moduleRoot}.`);
+		throw error;
+	}
+}
+async function assertFilesAbsent(filePaths) {
+	for (const filePath of filePaths) {
+		try {
+			await stat(filePath);
+		} catch (error) {
+			if (getErrorCode$1(error) === "ENOENT") continue;
+			throw error;
+		}
+		throw new ModuleScaffoldError(`${filePath} already exists; refusing to overwrite it.`);
+	}
+}
+async function writeGeneratedFiles(files) {
+	const written = [];
+	try {
+		for (const file of files) {
+			await mkdir(path.dirname(file.filePath), { recursive: true });
+			await writeFile(file.filePath, file.contents, "utf8");
+			written.push(file.filePath);
+		}
+	} catch (error) {
+		for (const filePath of written) await rm(filePath, { force: true });
+		throw error;
+	}
+	return written;
+}
+async function tryAddBuildDependencies(buildCsPath, moduleNames) {
+	let buildCsText;
+	try {
+		buildCsText = await readFile(buildCsPath, "utf8");
+	} catch (error) {
+		if (getErrorCode$1(error) === "ENOENT") return false;
+		throw error;
+	}
+	const addRangeIndex = buildCsText.indexOf("PrivateDependencyModuleNames.AddRange");
+	if (addRangeIndex < 0) return false;
+	const statementEnd = buildCsText.indexOf(";", addRangeIndex);
+	const openBrace = buildCsText.indexOf("{", addRangeIndex);
+	const closeBrace = openBrace < 0 ? -1 : buildCsText.indexOf("}", openBrace);
+	if (statementEnd < 0 || openBrace < 0 || closeBrace < 0 || openBrace > statementEnd) return false;
+	const body = buildCsText.slice(openBrace + 1, closeBrace);
+	const existing = new Set(Array.from(body.matchAll(/"([^"]+)"/g), (match) => match[1] ?? ""));
+	const missing = moduleNames.filter((moduleName) => !existing.has(moduleName));
+	if (missing.length === 0) return true;
+	const hasEntries = existing.size > 0;
+	const additions = missing.map((moduleName) => `                "${moduleName}"`).join(",\n");
+	const separator = hasEntries ? ",\n" : "\n";
+	const nextBody = `${body.replace(/\s+$/, "")}${separator}${additions}\n            `;
+	await writeFile(buildCsPath, `${buildCsText.slice(0, openBrace + 1)}${nextBody}${buildCsText.slice(closeBrace)}`, "utf8");
+	return true;
+}
+function buildNodeTypeName(nodeKind, className) {
+	switch (nodeKind) {
+		case "state_tree_task": return `F${className}Task`;
+		case "state_tree_condition": return `F${className}Condition`;
+		case "state_tree_evaluator": return `F${className}Evaluator`;
+		case "bt_task": return `UBTTask_${className}`;
+		case "bt_decorator": return `UBTDecorator_${className}`;
+		case "bt_service": return `UBTService_${className}`;
+		case "eqs_generator": return `UEnvQueryGenerator_${className}`;
+		default: return `UEnvQueryTest_${className}`;
+	}
+}
+function isStateTreeNode(nodeKind) {
+	return nodeKind.startsWith("state_tree_");
+}
+function renderNodeHeader(nodeKind, typeName, fileStem, displayName, apiMacro) {
+	if (isStateTreeNode(nodeKind)) return renderStateTreeNodeHeader(nodeKind, typeName, fileStem, displayName, apiMacro);
+	return renderObjectNodeHeader(nodeKind, typeName, fileStem, displayName, apiMacro);
+}
+function renderStateTreeNodeHeader(nodeKind, typeName, fileStem, displayName, apiMacro) {
+	const instanceDataType = `${typeName}InstanceData`;
+	return `#pragma once
+
+#include "CoreMinimal.h"
+
+#include "StateTreeExecutionContext.h"
+#include "${nodeKind === "state_tree_task" ? "StateTreeTaskBase.h" : nodeKind === "state_tree_condition" ? "StateTreeConditionBase.h" : "StateTreeEvaluatorBase.h"}"
+
+#include "${fileStem}.generated.h"
+
+// Per-run state for ${typeName}. A StateTree node is stateless — the tree hands it this struct — so
+// anything the node needs between ticks belongs here rather than on the node itself.
+USTRUCT()
+struct ${instanceDataType}
+{
+    GENERATED_BODY()
+};
+
+USTRUCT(meta = (DisplayName = "${displayName}", Category = "AI"))
+struct ${apiMacro} ${typeName} : public ${nodeKind === "state_tree_task" ? "FStateTreeTaskCommonBase" : nodeKind === "state_tree_condition" ? "FStateTreeConditionCommonBase" : "FStateTreeEvaluatorCommonBase"}
+{
+    GENERATED_BODY()
+
+    using FInstanceDataType = ${instanceDataType};
+
+    virtual const UStruct* GetInstanceDataType() const override
+    {
+        return FInstanceDataType::StaticStruct();
+    }
+${nodeKind === "state_tree_task" ? `
+    virtual EStateTreeRunStatus EnterState(
+        FStateTreeExecutionContext& Context,
+        const FStateTreeTransitionResult& Transition
+    ) const override;
+
+    virtual EStateTreeRunStatus Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const override;
+` : nodeKind === "state_tree_condition" ? `
+    virtual bool TestCondition(FStateTreeExecutionContext& Context) const override;
+` : `
+    virtual void Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const override;
+`}};
+`;
+}
+function renderObjectNodeHeader(nodeKind, typeName, fileStem, displayName, apiMacro) {
+	return `#pragma once
+
+#include "CoreMinimal.h"
+
+#include "${nodeKind === "bt_task" ? "BehaviorTree/BTTaskNode.h" : nodeKind === "bt_decorator" ? "BehaviorTree/BTDecorator.h" : nodeKind === "bt_service" ? "BehaviorTree/BTService.h" : nodeKind === "eqs_generator" ? "EnvironmentQuery/EnvQueryGenerator.h" : "EnvironmentQuery/EnvQueryTest.h"}"
+
+#include "${fileStem}.generated.h"
+
+UCLASS(meta = (DisplayName = "${displayName}"))
+class ${apiMacro} ${typeName} : public ${nodeKind === "bt_task" ? "UBTTaskNode" : nodeKind === "bt_decorator" ? "UBTDecorator" : nodeKind === "bt_service" ? "UBTService" : nodeKind === "eqs_generator" ? "UEnvQueryGenerator" : "UEnvQueryTest"}
+{
+    GENERATED_BODY()
+
+public:
+    ${typeName}();
+${nodeKind === "bt_task" ? `
+    virtual EBTNodeResult::Type ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) override;
+` : nodeKind === "bt_decorator" ? `
+protected:
+    virtual bool CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const override;
+` : nodeKind === "bt_service" ? `
+protected:
+    virtual void TickNode(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds) override;
+` : nodeKind === "eqs_generator" ? `
+    virtual void GenerateItems(FEnvQueryInstance& QueryInstance) const override;
+    virtual FText GetDescriptionTitle() const override;
+` : `
+    virtual void RunTest(FEnvQueryInstance& QueryInstance) const override;
+    virtual FText GetDescriptionTitle() const override;
+`}};
+`;
+}
+function renderNodeSource(nodeKind, typeName, fileStem) {
+	switch (nodeKind) {
+		case "state_tree_task": return `#include "${fileStem}.h"
+
+EStateTreeRunStatus ${typeName}::EnterState(
+    FStateTreeExecutionContext& Context,
+    const FStateTreeTransitionResult& Transition
+) const
+{
+    // Returning Running keeps the state alive until Tick decides otherwise; return Succeeded here for
+    // a task that does its whole job on entry.
+    return EStateTreeRunStatus::Running;
+}
+
+EStateTreeRunStatus ${typeName}::Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const
+{
+    return EStateTreeRunStatus::Running;
+}
+`;
+		case "state_tree_condition": return `#include "${fileStem}.h"
+
+bool ${typeName}::TestCondition(FStateTreeExecutionContext& Context) const
+{
+    return true;
+}
+`;
+		case "state_tree_evaluator": return `#include "${fileStem}.h"
+
+void ${typeName}::Tick(FStateTreeExecutionContext& Context, const float DeltaTime) const
+{
+}
+`;
+		case "bt_task": return `#include "${fileStem}.h"
+
+${typeName}::${typeName}()
+{
+    NodeName = TEXT("${typeName}");
+}
+
+EBTNodeResult::Type ${typeName}::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
+{
+    return EBTNodeResult::Succeeded;
+}
+`;
+		case "bt_decorator": return `#include "${fileStem}.h"
+
+${typeName}::${typeName}()
+{
+    NodeName = TEXT("${typeName}");
+}
+
+bool ${typeName}::CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
+{
+    return true;
+}
+`;
+		case "bt_service": return `#include "${fileStem}.h"
+
+${typeName}::${typeName}()
+{
+    NodeName = TEXT("${typeName}");
+    bNotifyTick = true;
+}
+
+void ${typeName}::TickNode(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds)
+{
+    Super::TickNode(OwnerComp, NodeMemory, DeltaSeconds);
+}
+`;
+		case "eqs_generator": return `#include "${fileStem}.h"
+
+#include "EnvironmentQuery/Items/EnvQueryItemType_Point.h"
+
+${typeName}::${typeName}()
+{
+    // Without an item type the query has nothing to score and every test silently rejects its items.
+    ItemType = UEnvQueryItemType_Point::StaticClass();
+}
+
+void ${typeName}::GenerateItems(FEnvQueryInstance& QueryInstance) const
+{
+}
+
+FText ${typeName}::GetDescriptionTitle() const
+{
+    return FText::FromString(TEXT("${typeName}"));
+}
+`;
+		default: return `#include "${fileStem}.h"
+
+#include "EnvironmentQuery/Items/EnvQueryItemType_Point.h"
+
+${typeName}::${typeName}()
+{
+    // Restricting the test to the item types it can actually read keeps it out of the picker for a
+    // query whose generator produces something else.
+    ValidItemType = UEnvQueryItemType_Point::StaticClass();
+}
+
+void ${typeName}::RunTest(FEnvQueryInstance& QueryInstance) const
+{
+}
+
+FText ${typeName}::GetDescriptionTitle() const
+{
+    return FText::FromString(TEXT("${typeName}"));
+}
+`;
+	}
 }
-async function exportBlueprintCpp(input, dependencies) {
-	const { summary, truncated: summaryTruncated } = await collectBlueprintSummary(input, dependencies);
-	const selected = input.graphName === void 0 ? summary.graphs.slice(0, input.maxGraphs) : summary.graphs.filter((graph) => graph.name === input.graphName);
-	if (input.graphName !== void 0 && selected.length === 0) throw new Error(`Blueprint '${summary.blueprintPath}' has no graph named '${input.graphName}'.`);
-	const rendered = [];
-	let truncated = summaryTruncated || input.graphName === void 0 && selected.length < summary.graphs.length;
-	for (const graph of selected) {
-		const { graphKind, nodes, truncated: graphTruncated } = await collectGraphNodes(input, graph.name, dependencies);
-		const pseudoCode = renderGraphPseudoCode({
-			graphKind,
-			graphName: graph.name,
-			nodes,
-			truncated: graphTruncated
-		});
-		truncated = truncated || pseudoCode.truncated;
-		rendered.push(pseudoCode);
+function buildTeamAgentTypeName(classKind, classPrefix) {
+	switch (classKind) {
+		case "controller": return `A${classPrefix}AIController`;
+		case "character": return `A${classPrefix}Character`;
+		default: return `F${classPrefix}TeamAttitudeSolver`;
 	}
-	const skeleton = renderCppSkeleton({
-		blueprintName: summary.blueprintName,
-		functions: summary.functions,
-		interfaces: summary.interfaces,
-		...summary.parentClass === void 0 ? {} : { parentClass: summary.parentClass },
-		variables: summary.variables
-	});
-	dependencies.logger.info({
-		blueprintPath: summary.blueprintPath,
-		graphCount: rendered.length,
-		projectId: summary.projectId
-	}, "Exported Blueprint graphs as pseudo-code");
-	return {
-		blueprintName: summary.blueprintName,
-		blueprintPath: summary.blueprintPath,
-		graphs: rendered,
-		projectId: summary.projectId,
-		pseudoCode: rendered.map((graph) => [`// ${graph.graphName} (${graph.graphKind})`, ...graph.lines].join("\n")).join("\n\n"),
-		skeleton,
-		truncated
-	};
 }
-const blueprintToolDomain = {
-	domain: "blueprint",
-	register: registerBlueprintTools,
-	toolNames: [
-		"find_blueprint_references",
-		"get_blueprint_summary",
-		"get_blueprint_graph",
-		"get_blueprint_compile_errors",
-		"compile_blueprint",
-		"get_blueprint_compile_status",
-		"create_blueprint",
-		"add_bp_variable",
-		"add_bp_function",
-		"add_bp_event",
-		"add_bp_component",
-		"add_bp_interface",
-		"set_bp_default",
-		"batch_edit",
-		"export_blueprint_cpp"
-	]
+function buildTeamAgentFileStem(classKind, classPrefix) {
+	switch (classKind) {
+		case "controller": return `${classPrefix}AIController`;
+		case "character": return `${classPrefix}Character`;
+		default: return `${classPrefix}TeamAttitudeSolver`;
+	}
+}
+function renderTeamAgentHeader(classKind, classPrefix, fileStem, apiMacro, defaultTeamId) {
+	if (classKind === "attitude_solver") return `#pragma once
+
+#include "CoreMinimal.h"
+
+#include "GenericTeamAgentInterface.h"
+
+// The attitude solver decides what every team id means to every other one. It is a single global
+// hook — FGenericTeamId::SetAttitudeSolver — so it is registered once at module startup and never
+// per actor; until it is registered, AI perception treats every non-matching id as hostile.
+struct ${apiMacro} F${classPrefix}TeamAttitudeSolver
+{
+    static ETeamAttitude::Type Solve(FGenericTeamId Lhs, FGenericTeamId Rhs);
+
+    // Call from your module's StartupModule.
+    static void Register();
+};
+`;
+	const includeLine = classKind === "controller" ? "#include \"AIController.h\"" : "#include \"GameFramework/Character.h\"";
+	const baseClass = classKind === "controller" ? "AAIController" : "ACharacter";
+	const typeName = buildTeamAgentTypeName(classKind, classPrefix);
+	return `#pragma once
+
+#include "CoreMinimal.h"
+
+${includeLine}
+#include "GenericTeamAgentInterface.h"
+
+#include "${fileStem}.generated.h"
+
+UCLASS()
+class ${apiMacro} ${typeName} : public ${baseClass}${classKind === "controller" ? "" : ", public IGenericTeamAgentInterface"}
+{
+    GENERATED_BODY()
+
+public:
+    ${typeName}();
+
+    // Both halves of IGenericTeamAgentInterface. Perception asks for the id through the interface, so
+    // an actor that only stores a team without answering here is still treated as having none.
+    virtual FGenericTeamId GetGenericTeamId() const override;
+    virtual void SetGenericTeamId(const FGenericTeamId& NewTeamId) override;
+
+protected:
+    // ${String(defaultTeamId)} by default; 255 is FGenericTeamId::NoTeam, which every attitude solver reads as neutral.
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Team")
+    uint8 TeamId = ${String(defaultTeamId)};
 };
+`;
+}
+function renderTeamAgentSource(classKind, classPrefix, fileStem, defaultTeamId) {
+	const typeName = buildTeamAgentTypeName(classKind, classPrefix);
+	if (classKind === "attitude_solver") return `#include "${fileStem}.h"
+
+ETeamAttitude::Type F${classPrefix}TeamAttitudeSolver::Solve(FGenericTeamId Lhs, FGenericTeamId Rhs)
+{
+    if (Lhs == FGenericTeamId::NoTeam || Rhs == FGenericTeamId::NoTeam)
+    {
+        return ETeamAttitude::Neutral;
+    }
+
+    return Lhs == Rhs ? ETeamAttitude::Friendly : ETeamAttitude::Hostile;
+}
+
+void F${classPrefix}TeamAttitudeSolver::Register()
+{
+    FGenericTeamId::SetAttitudeSolver(&F${classPrefix}TeamAttitudeSolver::Solve);
+}
+`;
+	return `#include "${fileStem}.h"
+
+${typeName}::${typeName}()
+{
+${classKind === "controller" ? `    // Written through the interface rather than straight onto the member so the controller and any
+    // pawn it possesses stay in step from the first frame.
+    SetGenericTeamId(FGenericTeamId(${String(defaultTeamId)}));` : `    TeamId = ${String(defaultTeamId)};`}
+}
+
+FGenericTeamId ${typeName}::GetGenericTeamId() const
+{
+    return FGenericTeamId(TeamId);
+}
+
+void ${typeName}::SetGenericTeamId(const FGenericTeamId& NewTeamId)
+{
+    TeamId = NewTeamId.GetId();
+}
+`;
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getErrorCode$1(error) {
+	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
+}
 //#endregion
 //#region src/classScaffold.ts
 const REFLECTED_MEMBER_KINDS = ["property", "function"];
@@ -15827,6 +17190,38 @@ function buildGetCreateClassStatusResult(response, projectId) {
 	if (response.sourcePath !== void 0) result.sourcePath = response.sourcePath;
 	return result;
 }
+const createAiNodeClassInputSchema = {
+	className: z.string().trim().min(1).max(96).describe("Bare class name without a prefix, e.g. 'MoveToCover'. The engine's prefix is added for you."),
+	descriptorPath: z.string().trim().min(1).describe("Absolute path to the .uproject or .uplugin the target module is registered in."),
+	displayName: z.string().trim().min(1).max(128).optional().describe("Name shown in the editor's node picker. Omitted uses the class name."),
+	moduleName: z.string().trim().min(1).max(128).describe("Existing module to generate into. Create it first with add_module if it does not exist."),
+	nodeKind: z.enum(AI_NODE_KINDS).describe("Which AI node to generate. Decides the base class and the override set."),
+	updateBuildCs: z.boolean().optional().describe("Add the node's required modules to the module's Build.cs (default true). Off only reports them.")
+};
+const createTeamAgentClassInputSchema = {
+	classKinds: z.array(z.enum(TEAM_AGENT_CLASS_KINDS)).min(1).max(3).describe("Which classes to generate: 'controller', 'character' and 'attitude_solver'. Perception only reports hostile or friendly once a solver is registered."),
+	classPrefix: z.string().trim().min(1).max(96).describe("Prefix for the generated types, e.g. 'Guard' produces AGuardAIController and AGuardCharacter."),
+	defaultTeamId: z.number().int().min(0).max(255).optional().describe("Team id the generated actors report by default (0-255, default 1). 255 is NoTeam."),
+	descriptorPath: z.string().trim().min(1).describe("Absolute path to the .uproject or .uplugin the target module is registered in."),
+	moduleName: z.string().trim().min(1).max(128).describe("Existing module to generate into."),
+	updateBuildCs: z.boolean().optional().describe("Add AIModule and GameplayTasks to the module's Build.cs (default true).")
+};
+async function createAiNodeClass(input, dependencies) {
+	const result = await scaffoldAiNodeClass(input);
+	dependencies.logger.info({
+		generatedTypes: result.generatedTypes,
+		moduleName: result.moduleName
+	}, "Scaffolded AI node class");
+	return result;
+}
+async function createTeamAgentClass(input, dependencies) {
+	const result = await scaffoldTeamAgentClass(input);
+	dependencies.logger.info({
+		generatedTypes: result.generatedTypes,
+		moduleName: result.moduleName
+	}, "Scaffolded team affiliation classes");
+	return result;
+}
 function registerCodeGenTools(server, dependencies) {
 	server.registerTool("add_module", {
 		description: "Scaffold a new Unreal C++ module (Source/<moduleName> with Build.cs, Public/<moduleName>.h, Private/<moduleName>.cpp) and register it in a .uproject or .uplugin descriptor. Pure filesystem scaffold; run generate_project_files + build_target afterward to compile it.",
@@ -15872,6 +17267,20 @@ function registerCodeGenTools(server, dependencies) {
 	}, async (input) => {
 		return toToolSuccess(await findSymbol(input, dependencies));
 	});
+	server.registerTool("create_ai_node_class", {
+		description: "Generate a C++ AI node class — a StateTree task, condition or evaluator, a Behavior Tree task, decorator or service, or an EQS generator or test — with the right base class, instance data struct, override signatures and prefix, plus the module dependencies it needs added to the module's Build.cs. Getting any of those wrong produces a class that compiles and never appears in the editor's node picker. Pure filesystem scaffold; run generate_project_files and build_target afterwards. For a Blueprint node use create_blueprint with the matching parent class instead.",
+		inputSchema: createAiNodeClassInputSchema,
+		title: "Create AI Node Class"
+	}, async ({ className, descriptorPath, displayName, moduleName, nodeKind, updateBuildCs }) => {
+		return toToolSuccess(await createAiNodeClass({
+			className,
+			descriptorPath,
+			displayName,
+			moduleName,
+			nodeKind,
+			updateBuildCs
+		}, dependencies));
+	});
 	server.registerTool("add_reflected_member", {
 		description: "Insert a UPROPERTY or UFUNCTION into an existing class or struct header, and append a matching .cpp stub for a function. Specifiers are validated against the UHT rules (conflicting edit/visibility specifiers, BlueprintReadOnly with BlueprintReadWrite, an RPC without Reliable/Unreliable or with a non-void return, a bare ReplicatedUsing) and nothing is written when they fail. The member goes in its own public: section right after GENERATED_BODY(), and any UE type it names by pointer or reference is forward-declared above the class. Server-side; does not require a running editor.",
 		inputSchema: addReflectedMemberInputSchema,
@@ -15886,6 +17295,20 @@ function registerCodeGenTools(server, dependencies) {
 	}, async (input) => {
 		return toToolSuccess(await scaffoldClassTemplate(input));
 	});
+	server.registerTool("create_team_agent_class", {
+		description: "Generate the C++ a team-based AI needs: an AIController and a Character that answer the generic team agent interface, and an attitude solver that decides what every team id means to every other one. Until a solver is registered, perception reports every actor with a different id as hostile and nothing as friendly, which is the behaviour this exists to replace. Pure filesystem scaffold; call the generated solver Register() from your module startup.",
+		inputSchema: createTeamAgentClassInputSchema,
+		title: "Create Team Agent Class"
+	}, async ({ classKinds, classPrefix, defaultTeamId, descriptorPath, moduleName, updateBuildCs }) => {
+		return toToolSuccess(await createTeamAgentClass({
+			classKinds,
+			classPrefix,
+			defaultTeamId,
+			descriptorPath,
+			moduleName,
+			updateBuildCs
+		}, dependencies));
+	});
 }
 const codeGenToolDomain = {
 	domain: "codeGen",
@@ -15896,7 +17319,9 @@ const codeGenToolDomain = {
 		"get_create_class_status",
 		"find_symbol",
 		"add_reflected_member",
-		"scaffold_class_template"
+		"scaffold_class_template",
+		"create_ai_node_class",
+		"create_team_agent_class"
 	]
 };
 //#endregion
@@ -17856,6 +19281,96 @@ const editorBuildToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/eqs.ts
+const getEqsQueryInputSchema = {
+	assetPath: bridgeGetEqsQueryRequestSchema.shape.assetPath.describe("Object path of the Environment Query asset to read."),
+	projectId: creativeProjectIdSchema
+};
+const editEqsQueryInputSchema = {
+	assetPath: bridgeEditEqsQueryRequestSchema.shape.assetPath.describe("Object path of the Environment Query asset to edit."),
+	generatorClass: bridgeEditEqsQueryRequestSchema.shape.generatorClass.describe("Replace the generator with this class. Omitted leaves the generator class alone."),
+	generatorParams: bridgeEditEqsQueryRequestSchema.shape.generatorParams.describe("Reflected properties written onto the generator, valued as ExportText."),
+	optionIndex: bridgeEditEqsQueryRequestSchema.shape.optionIndex.describe("Which query option to edit. Defaults 0, which is the only one most queries have."),
+	projectId: creativeProjectIdSchema,
+	tests: bridgeEditEqsQueryRequestSchema.shape.tests.describe("Test edits applied in order, each { operation, testIndex?, testClass?, purpose?, params?, toIndex? }. Indices address the list as it was before this call.")
+};
+const runEqsQueryInputSchema = {
+	assetPath: bridgeRunEqsQueryRequestFieldsSchema.shape.assetPath.describe("Object path of the Environment Query asset to run."),
+	maxItems: bridgeRunEqsQueryRequestFieldsSchema.shape.maxItems.describe("Maximum scored items to return (1-64, default 25)."),
+	projectId: creativeProjectIdSchema,
+	querierActorPath: bridgeRunEqsQueryRequestFieldsSchema.shape.querierActorPath.describe("Actor the query runs from. Most generators and every team test need one."),
+	querierLocation: bridgeRunEqsQueryRequestFieldsSchema.shape.querierLocation.describe("World location to run the query from when there is no querier actor."),
+	runMode: bridgeRunEqsQueryRequestFieldsSchema.shape.runMode.describe("EEnvQueryRunMode. 'all_matching' scores every item, which is what makes a run readable.")
+};
+async function getEqsQuery(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetEqsQueryRequest(input.assetPath), sendBridgeGetEqsQueryRequest, BRIDGE_GET_EQS_QUERY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function editEqsQuery(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeEditEqsQueryRequest(input.assetPath, {
+		generatorClass: input.generatorClass,
+		generatorParams: input.generatorParams,
+		optionIndex: input.optionIndex,
+		tests: input.tests
+	}), sendBridgeEditEqsQueryRequest, BRIDGE_EDIT_EQS_QUERY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function runEqsQuery(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeRunEqsQueryRequest(input.assetPath, {
+		maxItems: input.maxItems,
+		querierActorPath: input.querierActorPath,
+		querierLocation: input.querierLocation,
+		runMode: input.runMode
+	}), sendBridgeRunEqsQueryRequest, BRIDGE_RUN_EQS_QUERY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerEqsTools(server, dependencies) {
+	server.registerTool("get_eqs_query", {
+		description: "Read an Environment Query back: each option's generator with its settings, and every test with its purpose, settings and position in the run order. The test indices are what edit_eqs_query addresses, so this is the call to make before changing a query you did not author.",
+		inputSchema: getEqsQueryInputSchema,
+		title: "Get EQS Query"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getEqsQuery({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("edit_eqs_query", {
+		description: "Change an existing Environment Query: retune the generator, and add, update, remove or reorder its tests. Order matters — EQS runs filters before scores and a cheap filter placed first is the difference between a query that costs nothing and one that scores every item — so moving a test is a first-class operation rather than a delete and re-add.",
+		inputSchema: editEqsQueryInputSchema,
+		title: "Edit EQS Query"
+	}, async ({ assetPath, generatorClass, generatorParams, optionIndex, projectId, tests }) => {
+		return toToolSuccess(await editEqsQuery({
+			assetPath,
+			generatorClass,
+			generatorParams,
+			optionIndex,
+			projectId,
+			tests
+		}, dependencies));
+	});
+	server.registerTool("run_eqs_query", {
+		description: "Run an Environment Query in the editor world and return every generated item with its per-test scores and the winning one — the same numbers the EQS testing pawn draws, without placing one or entering Play In Editor. Use it to tune a query by running it, reading the scores and editing, rather than by guessing at weights.",
+		inputSchema: runEqsQueryInputSchema,
+		title: "Run EQS Query"
+	}, async ({ assetPath, maxItems, projectId, querierActorPath, querierLocation, runMode }) => {
+		return toToolSuccess(await runEqsQuery({
+			assetPath,
+			maxItems,
+			projectId,
+			querierActorPath,
+			querierLocation,
+			runMode
+		}, dependencies));
+	});
+}
+const eqsToolDomain = {
+	domain: "eqs",
+	register: registerEqsTools,
+	toolNames: [
+		"get_eqs_query",
+		"edit_eqs_query",
+		"run_eqs_query"
+	]
+};
+//#endregion
 //#region src/tools/foliage.ts
 const addFoliageTypeInputSchema = {
 	assetName: bridgeAddFoliageTypeRequestSchema.shape.assetName.describe("Name of the new foliage type, e.g. 'FT_Grass'."),
@@ -21023,6 +22538,115 @@ const pcgToolDomain = {
 	toolNames: ["create_pcg_graph", "run_pcg_generate"]
 };
 //#endregion
+//#region src/tools/perception.ts
+const createAiControllerInputSchema = {
+	addPerception: bridgeCreateAiControllerRequestFieldsSchema.shape.addPerception.describe("Add a perception component with no senses, which configure_ai_perception then fills in."),
+	assetName: bridgeCreateAiControllerRequestFieldsSchema.shape.assetName.describe("Name of the new controller Blueprint, e.g. 'BP_GuardController'."),
+	autoPossess: bridgeCreateAiControllerRequestFieldsSchema.shape.autoPossess.describe("EAutoPossessAI value written onto the pawn class, so a pawn placed in the level gets this controller."),
+	behaviorTreePath: bridgeCreateAiControllerRequestFieldsSchema.shape.behaviorTreePath.describe("Behavior Tree the controller runs on possess. Required when brainKind is 'behavior_tree'."),
+	blackboardPath: bridgeCreateAiControllerRequestFieldsSchema.shape.blackboardPath.describe("Blackboard to initialize. Omitted uses the Behavior Tree's own."),
+	brainKind: bridgeCreateAiControllerRequestFieldsSchema.shape.brainKind.describe("What runs the AI: 'behavior_tree', 'state_tree', or 'none' for a controller whose subclass decides."),
+	packagePath: bridgeCreateAiControllerRequestFieldsSchema.shape.packagePath.describe("Content folder to create the controller in."),
+	parentClass: bridgeCreateAiControllerRequestFieldsSchema.shape.parentClass.describe("Parent class for the Blueprint. Omitted uses AIController."),
+	pawnClassPath: bridgeCreateAiControllerRequestFieldsSchema.shape.pawnClassPath.describe("Pawn class to assign this controller to. Assigning it recompiles that Blueprint."),
+	projectId: creativeProjectIdSchema,
+	stateTreePath: bridgeCreateAiControllerRequestFieldsSchema.shape.stateTreePath.describe("StateTree the controller runs. Required when brainKind is 'state_tree'.")
+};
+const configureAiPerceptionInputSchema = {
+	blueprintPath: bridgeConfigureAiPerceptionRequestSchema.shape.blueprintPath.describe("Object path of the Blueprint whose perception component to configure."),
+	componentName: bridgeConfigureAiPerceptionRequestSchema.shape.componentName.describe("Perception component to edit. Omitted edits the first one on the Blueprint."),
+	dominantSense: bridgeConfigureAiPerceptionRequestSchema.shape.dominantSense.describe("Sense that decides where a perceived actor is reported from when several fire at once."),
+	projectId: creativeProjectIdSchema,
+	senses: bridgeConfigureAiPerceptionRequestSchema.shape.senses.describe("Senses to write, each { senseKind, mode?, params?, detectEnemies?, detectNeutrals?, detectFriendlies? }. Every affiliation flag off is why a well-configured sense detects nothing.")
+};
+const addStimuliSourceInputSchema = {
+	autoRegisterAsSource: bridgeAddStimuliSourceRequestSchema.shape.autoRegisterAsSource.describe("Register the actor with the perception system on begin play. Off leaves it invisible until something registers it by hand."),
+	blueprintPath: bridgeAddStimuliSourceRequestSchema.shape.blueprintPath.describe("Object path of the Blueprint to make perceivable."),
+	componentName: bridgeAddStimuliSourceRequestSchema.shape.componentName.describe("Name for the new stimuli source component. Omitted uses AIPerceptionStimuliSource."),
+	projectId: creativeProjectIdSchema,
+	senses: bridgeAddStimuliSourceRequestSchema.shape.senses.describe("Senses the actor registers itself for. An actor registered for no sense is perceived by nothing.")
+};
+async function createAiController(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateAiControllerRequest(input.assetName, input.packagePath, {
+		addPerception: input.addPerception,
+		autoPossess: input.autoPossess,
+		behaviorTreePath: input.behaviorTreePath,
+		blackboardPath: input.blackboardPath,
+		brainKind: input.brainKind,
+		parentClass: input.parentClass,
+		pawnClassPath: input.pawnClassPath,
+		stateTreePath: input.stateTreePath
+	}), sendBridgeCreateAiControllerRequest, BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function configureAiPerception(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeConfigureAiPerceptionRequest(input.blueprintPath, input.senses, {
+		componentName: input.componentName,
+		dominantSense: input.dominantSense
+	}), sendBridgeConfigureAiPerceptionRequest, BRIDGE_CONFIGURE_AI_PERCEPTION_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addStimuliSource(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddStimuliSourceRequest(input.blueprintPath, input.senses, {
+		autoRegisterAsSource: input.autoRegisterAsSource,
+		componentName: input.componentName
+	}), sendBridgeAddStimuliSourceRequest, BRIDGE_ADD_STIMULI_SOURCE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerPerceptionTools(server, dependencies) {
+	server.registerTool("create_ai_controller", {
+		description: "Create an AIController Blueprint that runs a Behavior Tree or a StateTree on possess, optionally with a perception component, and assign it to a pawn class with auto-possess — the several-asset setup that otherwise takes a handful of separate calls. Assigning the controller recompiles the pawn Blueprint, which the response names rather than doing silently.",
+		inputSchema: createAiControllerInputSchema,
+		title: "Create AI Controller"
+	}, async ({ addPerception, assetName, autoPossess, behaviorTreePath, blackboardPath, brainKind, packagePath, parentClass, pawnClassPath, projectId, stateTreePath }) => {
+		return toToolSuccess(await createAiController({
+			addPerception,
+			assetName,
+			autoPossess,
+			behaviorTreePath,
+			blackboardPath,
+			brainKind,
+			packagePath,
+			parentClass,
+			pawnClassPath,
+			projectId,
+			stateTreePath
+		}, dependencies));
+	});
+	server.registerTool("configure_ai_perception", {
+		description: "Configure the senses on a Blueprint's AI perception component — sight cones and radii, hearing range, damage, team and touch — including the affiliation flags that decide what each sense reports at all. Every affiliation off is the default on a fresh sight config and the usual reason a perfectly configured sense detects nothing.",
+		inputSchema: configureAiPerceptionInputSchema,
+		title: "Configure AI Perception"
+	}, async ({ blueprintPath, componentName, dominantSense, projectId, senses }) => {
+		return toToolSuccess(await configureAiPerception({
+			blueprintPath,
+			componentName,
+			dominantSense,
+			projectId,
+			senses
+		}, dependencies));
+	});
+	server.registerTool("add_stimuli_source", {
+		description: "Make an actor perceivable by adding a stimuli source component registered for the senses it should be detected by. This is the half of perception setup that is easy to forget: an actor that registers for no sense is invisible to every perception component in the level, however well those are configured.",
+		inputSchema: addStimuliSourceInputSchema,
+		title: "Add Stimuli Source"
+	}, async ({ autoRegisterAsSource, blueprintPath, componentName, projectId, senses }) => {
+		return toToolSuccess(await addStimuliSource({
+			autoRegisterAsSource,
+			blueprintPath,
+			componentName,
+			projectId,
+			senses
+		}, dependencies));
+	});
+}
+const perceptionToolDomain = {
+	domain: "perception",
+	register: registerPerceptionTools,
+	toolNames: [
+		"create_ai_controller",
+		"configure_ai_perception",
+		"add_stimuli_source"
+	]
+};
+//#endregion
 //#region src/tools/postProcess.ts
 const createPostProcessVolumeInputSchema = {
 	actorLabel: bridgeCreatePostProcessVolumeRequestSchema.shape.actorLabel.describe("Label for the placed volume. Omitted lets the editor name it."),
@@ -21765,6 +23389,160 @@ const sequencerToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/stateTree.ts
+const getStateTreeInputSchema = {
+	assetPath: bridgeGetStateTreeRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to read."),
+	projectId: creativeProjectIdSchema
+};
+const setStateTreeGlobalsInputSchema = {
+	assetPath: bridgeSetStateTreeGlobalsRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to edit."),
+	compile: bridgeSetStateTreeGlobalsRequestSchema.shape.compile.describe("Run the StateTree compiler after the edit. Defaults true — an evaluator is not visible to states until the tree compiles."),
+	mode: bridgeSetStateTreeGlobalsRequestSchema.shape.mode.describe("'merge' appends to what the tree already carries; 'replace' makes the root's lists exactly what was sent, which is the only way to remove one."),
+	nodes: bridgeSetStateTreeGlobalsRequestSchema.shape.nodes.describe("Tree-level nodes, each { kind, nodeClass, params? }. kind is 'evaluator' or 'global_task'; nodeClass names a script struct such as '/Script/StateTreeModule.StateTreeEvaluatorBase' subclass."),
+	projectId: creativeProjectIdSchema
+};
+const setStateTreeConsiderationsInputSchema = {
+	assetPath: bridgeSetStateTreeConsiderationsRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to edit."),
+	compile: bridgeSetStateTreeConsiderationsRequestSchema.shape.compile.describe("Run the StateTree compiler after the edit. Defaults true."),
+	projectId: creativeProjectIdSchema,
+	states: bridgeSetStateTreeConsiderationsRequestSchema.shape.states.describe("States to score, each { stateName, selectionBehavior?, weight?, considerations? }. Considerations are { nodeClass, params? }. The weight scales the whole state score, because that is where the engine keeps it, and it only matters under a utility selection behaviour.")
+};
+const linkStateTreeStateInputSchema = {
+	assetPath: bridgeLinkStateTreeStateRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to edit."),
+	compile: bridgeLinkStateTreeStateRequestSchema.shape.compile.describe("Run the StateTree compiler after the edit. Defaults true."),
+	links: bridgeLinkStateTreeStateRequestSchema.shape.links.describe("Links to apply, each { stateName, linkType, targetStateName?, linkedAssetPath?, parameterOverrides? }. A 'linked_state' names a state in this tree; a 'linked_asset' names another StateTree."),
+	projectId: creativeProjectIdSchema
+};
+const addStateTreeComponentInputSchema = {
+	blueprintPath: bridgeAddStateTreeComponentRequestSchema.shape.blueprintPath.describe("Object path of the Blueprint to add the component to."),
+	componentKind: bridgeAddStateTreeComponentRequestSchema.shape.componentKind.describe("'state_tree' runs any actor-schema tree; 'state_tree_ai' is the AIController-bound component the AI schema's tasks need."),
+	componentName: bridgeAddStateTreeComponentRequestSchema.shape.componentName.describe("Name for the new component. Omitted names it after its kind."),
+	projectId: creativeProjectIdSchema,
+	startLogicAutomatically: bridgeAddStateTreeComponentRequestSchema.shape.startLogicAutomatically.describe("Start the tree when the component begins play. Off leaves it assigned but dormant."),
+	stateTreePath: bridgeAddStateTreeComponentRequestSchema.shape.stateTreePath.describe("Object path of the StateTree asset to assign. Its schema must match the component kind.")
+};
+const traceStateTreeInputSchema = {
+	action: bridgeTraceStateTreeRequestSchema.shape.action.describe("'start' begins recording, 'poll' drains what has been recorded so far, 'stop' ends the recording and drains the rest."),
+	actorPath: bridgeTraceStateTreeRequestSchema.shape.actorPath.describe("Actor to record. Omitted on start records every StateTree in the session, which floods quickly."),
+	maxEvents: bridgeTraceStateTreeRequestSchema.shape.maxEvents.describe("Maximum events to return in one poll (1-200, default 50)."),
+	projectId: creativeProjectIdSchema
+};
+async function getStateTree(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetStateTreeRequest(input.assetPath), sendBridgeGetStateTreeRequest, BRIDGE_GET_STATE_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setStateTreeGlobals(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetStateTreeGlobalsRequest(input.assetPath, input.nodes ?? [], {
+		compile: input.compile,
+		mode: input.mode
+	}), sendBridgeSetStateTreeGlobalsRequest, BRIDGE_SET_STATE_TREE_GLOBALS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setStateTreeConsiderations(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetStateTreeConsiderationsRequest(input.assetPath, input.states, { compile: input.compile }), sendBridgeSetStateTreeConsiderationsRequest, BRIDGE_SET_STATE_TREE_CONSIDERATIONS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function linkStateTreeState(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeLinkStateTreeStateRequest(input.assetPath, input.links, { compile: input.compile }), sendBridgeLinkStateTreeStateRequest, BRIDGE_LINK_STATE_TREE_STATE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addStateTreeComponent(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddStateTreeComponentRequest(input.blueprintPath, input.stateTreePath, {
+		componentKind: input.componentKind,
+		componentName: input.componentName,
+		startLogicAutomatically: input.startLogicAutomatically
+	}), sendBridgeAddStateTreeComponentRequest, BRIDGE_ADD_STATE_TREE_COMPONENT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function traceStateTree(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeTraceStateTreeRequest(input.action, {
+		actorPath: input.actorPath,
+		maxEvents: input.maxEvents
+	}), sendBridgeTraceStateTreeRequest, BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerStateTreeTools(server, dependencies) {
+	server.registerTool("get_state_tree", {
+		description: "Read a StateTree back: its schema, parameters, evaluators, global tasks and the full state hierarchy with each state's tasks, enter conditions and transitions. Every state and node carries the id the edit tools address it by, so this is the call to make before editing a tree you did not author. compiled reports whether the asset carries runtime data — a tree that reads back correctly with compiled false is authored but will not run.",
+		inputSchema: getStateTreeInputSchema,
+		title: "Get StateTree"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getStateTree({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_state_tree_globals", {
+		description: "Add or replace the evaluators and global tasks on a StateTree's root. An evaluator produces values every tick for states to bind against; a global task runs for the whole lifetime of the tree. The tree is recompiled by default because an evaluator's output is not visible to any state until it is.",
+		inputSchema: setStateTreeGlobalsInputSchema,
+		title: "Set StateTree Globals"
+	}, async ({ assetPath, compile, mode, nodes, projectId }) => {
+		return toToolSuccess(await setStateTreeGlobals({
+			assetPath,
+			compile,
+			mode,
+			nodes,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_state_tree_considerations", {
+		description: "Switch states to utility-scored selection and give them weighted considerations, so the parent picks the highest-scoring child rather than the first one whose conditions pass. Utility selection only exists on newer engines: on an older one nothing is written, supported comes back false and supportedVersions names the engines that have it.",
+		inputSchema: setStateTreeConsiderationsInputSchema,
+		title: "Set StateTree Considerations"
+	}, async ({ assetPath, compile, projectId, states }) => {
+		return toToolSuccess(await setStateTreeConsiderations({
+			assetPath,
+			compile,
+			projectId,
+			states
+		}, dependencies));
+	});
+	server.registerTool("link_state_tree_state", {
+		description: "Turn states into linked states or linked assets so a subtree can be reused. A 'linked_state' runs another state in the same tree; a 'linked_asset' runs a whole other StateTree, which is the reuse unit that survives being edited somewhere else. Parameter overrides are checked against the target's own parameters rather than dropped.",
+		inputSchema: linkStateTreeStateInputSchema,
+		title: "Link StateTree State"
+	}, async ({ assetPath, compile, links, projectId }) => {
+		return toToolSuccess(await linkStateTreeState({
+			assetPath,
+			compile,
+			links,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_state_tree_component", {
+		description: "Add a StateTree component to a Blueprint with the tree assigned, which is what makes an authored tree actually run on an actor. The tree's schema is checked against the component kind and a mismatch is refused rather than left to fail at runtime. When the engine plugin that provides the AI component is switched off, the response comes back unsupported with the reason instead of failing.",
+		inputSchema: addStateTreeComponentInputSchema,
+		title: "Add StateTree Component"
+	}, async ({ blueprintPath, componentKind, componentName, projectId, startLogicAutomatically, stateTreePath }) => {
+		return toToolSuccess(await addStateTreeComponent({
+			blueprintPath,
+			componentKind,
+			componentName,
+			projectId,
+			startLogicAutomatically,
+			stateTreePath
+		}, dependencies));
+	});
+	server.registerTool("trace_state_tree", {
+		description: "Record and read back what a StateTree did during Play In Editor: which states were entered and left, which transitions fired and why, and how each task and condition answered, each stamped with seconds since the recording started. Start the recording, run the fixture, then poll. droppedCount tells a quiet fixture apart from one whose trace outran the buffer.",
+		inputSchema: traceStateTreeInputSchema,
+		title: "Trace StateTree"
+	}, async ({ action, actorPath, maxEvents, projectId }) => {
+		return toToolSuccess(await traceStateTree({
+			action,
+			actorPath,
+			maxEvents,
+			projectId
+		}, dependencies));
+	});
+}
+const stateTreeToolDomain = {
+	domain: "stateTree",
+	register: registerStateTreeTools,
+	toolNames: [
+		"get_state_tree",
+		"set_state_tree_globals",
+		"set_state_tree_considerations",
+		"link_state_tree_state",
+		"add_state_tree_component",
+		"trace_state_tree"
+	]
+};
+//#endregion
 //#region src/tools/toolchain.ts
 const buildTimeoutSchema = z.number().int().min(1e3).max(MAX_PROCESS_TIMEOUT_MS).optional().describe(`Hard timeout in milliseconds before the child process is killed (default ${DEFAULT_PROCESS_TIMEOUT_MS}).`);
 const platformSchema = z.enum(UNREAL_TARGET_PLATFORMS).optional().describe("Target platform; defaults to the host platform (Win64/Mac/Linux).");
@@ -22678,6 +24456,9 @@ const TOOL_CATALOG = [
 	inputToolDomain,
 	abilitiesToolDomain,
 	behaviorTreeToolDomain,
+	stateTreeToolDomain,
+	perceptionToolDomain,
+	eqsToolDomain,
 	animToolDomain,
 	umgToolDomain,
 	renderToolDomain,