blueprint-extractor-mcp 3.2.0 → 4.0.0

package/dist/catalogs/example-catalog.js

@@ -482,4 +482,92 @@ export const exampleCatalog = {
             },
         ],
     },
+    state_tree_bindings: {
+        summary: 'Wire task outputs to task inputs using property path bindings. Extract an existing StateTree to discover structIds and property names, then use binding operations to set up data flow.',
+        recommended_flow: [
+            'extract_asset (discover structIds and property names)',
+            'modify_state_tree (add_binding / set_bindings)',
+            'extract_asset (verify bindings)',
+            'save_assets',
+        ],
+        examples: [
+            {
+                title: 'add_single_binding',
+                tool: 'modify_state_tree',
+                arguments: {
+                    asset_path: '/Game/AI/ST_Character',
+                    operation: 'add_binding',
+                    payload: {
+                        sourcePath: {
+                            structId: 'EAB9611F4B07D7E2C25A948AFC790A50',
+                            segments: [{ name: 'SelectedGestureTag' }],
+                        },
+                        targetPath: {
+                            structId: 'F2A3B44C4D08E6A1C25A948AFC790A50',
+                            segments: [{ name: 'MontageTag' }],
+                        },
+                    },
+                },
+                context: { description: 'Wire SelectRandomGesture output → PlayMontage input. structIds from extract_asset output.' },
+            },
+            {
+                title: 'set_all_bindings',
+                tool: 'modify_state_tree',
+                arguments: {
+                    asset_path: '/Game/AI/ST_Character',
+                    operation: 'set_bindings',
+                    payload: {
+                        propertyBindings: [
+                            {
+                                sourcePath: { segments: [{ name: 'SelectedTag' }] },
+                                targetPath: { segments: [{ name: 'MontageTag' }] },
+                            },
+                            {
+                                sourcePath: { segments: [{ name: 'Duration' }] },
+                                targetPath: { segments: [{ name: 'WaitTime' }] },
+                            },
+                        ],
+                    },
+                },
+                context: { description: 'Replace all bindings on the StateTree with a new set.' },
+            },
+            {
+                title: 'remove_binding_by_target',
+                tool: 'modify_state_tree',
+                arguments: {
+                    asset_path: '/Game/AI/ST_Character',
+                    operation: 'remove_binding',
+                    payload: {
+                        targetPath: { segments: [{ name: 'MontageTag' }] },
+                    },
+                },
+                context: { description: 'Remove all bindings targeting the MontageTag property.' },
+            },
+            {
+                title: 'create_with_bindings',
+                tool: 'create_state_tree',
+                arguments: {
+                    asset_path: '/Game/AI/ST_NewWithBindings',
+                    payload: {
+                        schema: '/Script/GameplayStateTreeModule.StateTreeComponentSchema',
+                        states: [{
+                                name: 'Root',
+                                type: 'State',
+                                tasks: [
+                                    { nodeStructType: '/Script/MyMod.STCSelectGesture', name: 'SelectGesture' },
+                                    { nodeStructType: '/Script/MyMod.STCPlayMontage', name: 'PlayMontage' },
+                                ],
+                            }],
+                        bindings: {
+                            propertyBindings: [{
+                                    sourcePath: { segments: [{ name: 'SelectedGestureTag' }] },
+                                    targetPath: { segments: [{ name: 'MontageTag' }] },
+                                }],
+                        },
+                    },
+                },
+                context: { description: 'Create a StateTree with tasks and bindings in a single call.' },
+            },
+        ],
+    },
 };

package/dist/helpers/alias-registration.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolHelpEntry, ToolInputSchema } from './tool-help.js';
+type RawToolHandler = (args: Record<string, unknown>, extra: unknown) => Promise<unknown> | unknown;
+export declare const aliasMap: Map<string, string>;
+export declare const rawHandlerRegistry: Map<string, RawToolHandler>;
+export declare function registerAlias(server: McpServer, oldName: string, targetName: string, parameterMapping: (args: Record<string, unknown>) => Record<string, unknown>, deprecationMessage: string, toolHelpRegistry: Map<string, ToolHelpEntry>, aliasInputSchema?: ToolInputSchema): void;
+export {};

package/dist/helpers/alias-registration.js

@@ -0,0 +1,36 @@
+// Global alias map: old name -> new name
+export const aliasMap = new Map();
+// Registry for raw (pre-normalization) handlers, keyed by tool name.
+// Populated by installNormalizedToolRegistration and used by alias delegation.
+export const rawHandlerRegistry = new Map();
+export function registerAlias(server, oldName, targetName, parameterMapping, deprecationMessage, toolHelpRegistry, aliasInputSchema) {
+    const targetEntry = toolHelpRegistry.get(targetName);
+    if (!targetEntry) {
+        throw new Error(`Cannot register alias '${oldName}': target tool '${targetName}' not found in registry`);
+    }
+    const targetHandler = rawHandlerRegistry.get(targetName);
+    if (!targetHandler) {
+        throw new Error(`Cannot register alias '${oldName}': no raw handler found for target tool '${targetName}'`);
+    }
+    aliasMap.set(oldName, targetName);
+    const aliasDescription = `[DEPRECATED: use ${targetName}] ${targetEntry.description}`;
+    server.registerTool(oldName, {
+        title: `${targetEntry.title} (deprecated alias)`,
+        description: aliasDescription,
+        inputSchema: aliasInputSchema ?? targetEntry.inputSchema,
+        annotations: {
+            ...targetEntry.annotations,
+        },
+    }, async (args, extra) => {
+        const mappedArgs = parameterMapping(args);
+        return targetHandler(mappedArgs, extra);
+    });
+    toolHelpRegistry.set(oldName, {
+        ...targetEntry,
+        title: `${targetEntry.title} (deprecated alias)`,
+        description: `Alias for ${targetName}. ${deprecationMessage} ${targetEntry.description}`,
+        annotations: {
+            ...targetEntry.annotations,
+        },
+    });
+}

package/dist/helpers/composite-patterns.d.ts

@@ -0,0 +1,40 @@
+export interface CompositeStepResult {
+    step: string;
+    status: 'success' | 'failure' | 'skipped';
+    message?: string;
+    data?: Record<string, unknown>;
+    diagnostics?: Array<{
+        severity?: string;
+        code?: string;
+        message?: string;
+        path?: string;
+    }>;
+}
+export interface CompositeToolResult {
+    success: boolean;
+    operation: string;
+    steps: CompositeStepResult[];
+    partial_state?: {
+        completed_steps: string[];
+        failed_step: string;
+        editor_state: string;
+    };
+    execution: {
+        mode: 'immediate' | 'task_aware';
+        task_support: 'optional' | 'required' | 'forbidden';
+        status?: string;
+        progress_message?: string;
+    };
+}
+type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function safeCall<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+export declare function compositeSuccess(operation: string, steps: CompositeStepResult[], execution: CompositeToolResult['execution']): CompositeToolResult;
+export declare function compositeError(operation: string, steps: CompositeStepResult[], failedStep: string, execution: CompositeToolResult['execution']): CompositeToolResult;
+export declare function compositePartialFailure(operation: string, steps: CompositeStepResult[], failedStep: string, partialState: CompositeToolResult['partial_state'], execution: CompositeToolResult['execution']): CompositeToolResult;
+export {};

package/dist/helpers/composite-patterns.js

@@ -0,0 +1,28 @@
+export async function safeCall(fn) {
+    try {
+        const value = await fn();
+        return { ok: true, value };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e : new Error(String(e)) };
+    }
+}
+export function compositeSuccess(operation, steps, execution) {
+    return { success: true, operation, steps, execution };
+}
+export function compositeError(operation, steps, failedStep, execution) {
+    return {
+        success: false,
+        operation,
+        steps,
+        partial_state: {
+            completed_steps: steps.filter(s => s.status === 'success').map(s => s.step),
+            failed_step: failedStep,
+            editor_state: 'No mutations performed; editor state unchanged',
+        },
+        execution,
+    };
+}
+export function compositePartialFailure(operation, steps, failedStep, partialState, execution) {
+    return { success: false, operation, steps, partial_state: partialState, execution };
+}

package/dist/helpers/live-coding.js

@@ -36,6 +36,10 @@ export function enrichLiveCodingResult(result, changedPaths = [], lastExternalBu
         warnings.push('Live Coding cannot add, remove, or reorder UPROPERTYs or change class layouts. '
             + 'Use compile_project_code + restart_editor for class layout changes.');
     }
+    if (result.noOp && typeof result.compileResult === 'string' && result.compileResult.toLowerCase() === 'nochanges') {
+        warnings.push('Live Coding cannot compile newly added source files — it only detects changes to already-compiled .obj files. '
+            + 'Use compile_project_code for new files, then restart_editor to load the new module.');
+    }
     const fallbackRecommended = canFallbackFromLiveCoding(result);
     const reason = deriveLiveCodingFallbackReason(result);
     return {

package/dist/helpers/subsystem.js

@@ -47,13 +47,40 @@ export async function callSubsystemJson(client, method, params, options) {
     }
     return parsed;
 }
+/**
+ * Extracts the best available error message from a UE failure response,
+ * checking message, errorMessage, error, diagnostics[], and errors[] fields
+ * before falling back to listing the available response keys.
+ */
+function extractFailureMessage(parsed) {
+    if (typeof parsed.message === 'string' && parsed.message.length > 0)
+        return parsed.message;
+    if (typeof parsed.errorMessage === 'string' && parsed.errorMessage.length > 0)
+        return parsed.errorMessage;
+    if (typeof parsed.error === 'string' && parsed.error.length > 0)
+        return parsed.error;
+    if (Array.isArray(parsed.diagnostics) && parsed.diagnostics.length > 0) {
+        const messages = parsed.diagnostics
+            .filter((d) => typeof d === 'object' && d !== null && typeof d.message === 'string')
+            .map((d) => d.message);
+        if (messages.length > 0)
+            return messages.join('; ');
+    }
+    if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
+        const first = parsed.errors[0];
+        return typeof first === 'string' ? first : JSON.stringify(first);
+    }
+    const keys = Object.keys(parsed).join(', ');
+    return `Operation returned success:false with no diagnostic details. Response keys: [${keys}]`;
+}
 export function jsonToolSuccess(parsed, options = {}) {
     const structuredContent = isRecord(parsed) ? parsed : { data: parsed };
     // Guard: if the UE response indicates failure, route through error path.
     // This prevents tool handlers from accidentally passing error payloads as successes.
     if (isRecord(parsed) && parsed.success === false) {
+        const errorText = extractFailureMessage(parsed);
         return {
-            content: [{ type: 'text', text: `Error: ${typeof parsed.message === 'string' ? parsed.message : 'Operation failed'}` }],
+            content: [{ type: 'text', text: `Error: ${errorText}` }],
             structuredContent,
             isError: true,
         };

package/dist/helpers/tool-registration.d.ts

@@ -1,13 +1,14 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer, type RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { ToolHelpEntry } from './tool-help.js';
 type ToolNormalizer = (...args: any[]) => unknown;
 type InstallNormalizedToolRegistrationOptions = {
     server: McpServer;
     toolHelpRegistry: Map<string, ToolHelpEntry>;
+    registeredToolMap: Map<string, RegisteredTool>;
     defaultOutputSchema: z.ZodTypeAny;
     normalizeToolError: ToolNormalizer;
     normalizeToolSuccess: ToolNormalizer;
 };
-export declare function installNormalizedToolRegistration({ server, toolHelpRegistry, defaultOutputSchema, normalizeToolError, normalizeToolSuccess, }: InstallNormalizedToolRegistrationOptions): void;
+export declare function installNormalizedToolRegistration({ server, toolHelpRegistry, registeredToolMap, defaultOutputSchema, normalizeToolError, normalizeToolSuccess, }: InstallNormalizedToolRegistrationOptions): void;
 export {};

package/dist/helpers/tool-registration.js

@@ -1,8 +1,10 @@
 import { extractExtraContent, extractToolPayload, isRecord } from './formatting.js';
-export function installNormalizedToolRegistration({ server, toolHelpRegistry, defaultOutputSchema, normalizeToolError, normalizeToolSuccess, }) {
+import { rawHandlerRegistry } from './alias-registration.js';
+export function installNormalizedToolRegistration({ server, toolHelpRegistry, registeredToolMap, defaultOutputSchema, normalizeToolError, normalizeToolSuccess, }) {
     const rawRegisterTool = server.registerTool.bind(server);
     server.registerTool = ((name, config, cb) => {
         const outputSchema = (config.outputSchema ?? defaultOutputSchema);
+        rawHandlerRegistry.set(name, cb);
         toolHelpRegistry.set(name, {
             title: config.title ?? name,
             description: config.description ?? '',
@@ -10,7 +12,7 @@ export function installNormalizedToolRegistration({ server, toolHelpRegistry, de
             outputSchema,
             annotations: config.annotations,
         });
-        return rawRegisterTool(name, {
+        const registered = rawRegisterTool(name, {
             ...config,
             outputSchema,
         }, async (args, extra) => {
@@ -25,5 +27,7 @@ export function installNormalizedToolRegistration({ server, toolHelpRegistry, de
                 return normalizeToolError(name, error);
             }
         });
+        registeredToolMap.set(name, registered);
+        return registered;
     });
 }

package/dist/helpers/tool-results.js

@@ -1,3 +1,4 @@
+import { aliasMap } from './alias-registration.js';
 import { isRecord } from './formatting.js';
 export function createToolResultNormalizers({ taskAwareTools, classifyRecoverableToolFailure, }) {
     function extractNonTextContent(existingResult) {
@@ -9,20 +10,21 @@ export function createToolResultNormalizers({ taskAwareTools, classifyRecoverabl
             && entry.type !== 'text'));
     }
     function defaultNextSteps(toolName, payload) {
-        if (toolName === 'wait_for_editor') {
+        const resolvedName = aliasMap.get(toolName) ?? toolName;
+        if (resolvedName === 'wait_for_editor') {
             return [
                 'Retry wait_for_editor if the editor is still restarting.',
                 'Once connected=true, rerun the blocked editor-backed tool.',
             ];
         }
-        if (toolName === 'compile_widget_blueprint') {
+        if (resolvedName === 'compile_widget_blueprint') {
             return [
                 'Inspect compile.messages and diagnostics for the first failing widget or property.',
                 'Re-extract the widget blueprint before applying the next structural patch.',
                 'Check BindWidget names/types and any abstract classes referenced by the widget tree.',
             ];
         }
-        if (taskAwareTools.has(toolName)) {
+        if (taskAwareTools.has(resolvedName)) {
             return [
                 'Inspect the returned execution.status and diagnostics before retrying.',
                 'Poll the task-oriented status tool again if the operation is still running.',

package/dist/index.js

@@ -6,7 +6,7 @@ export { createBlueprintExtractorServer } from './server-factory.js';
 export { exampleCatalog } from './catalogs/example-catalog.js';
 export { promptCatalog } from './prompts/prompt-catalog.js';
 async function main() {
-    const server = createBlueprintExtractorServer();
+    const { server } = createBlueprintExtractorServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/project-controller.d.ts

@@ -51,6 +51,7 @@ export interface CompileProjectCodeResult {
     stdout?: string;
     stderr?: string;
     uhtCacheFilesDeleted?: string[];
+    compilationSucceeded: boolean;
     errorCategory?: BuildErrorCategory;
     errorSummary?: string;
     lockedFiles?: string[];
@@ -104,6 +105,10 @@ export interface ProjectControllerLike {
     readonly liveCodingSupported: boolean;
     classifyChangedPaths(changedPaths: string[], forceRebuild?: boolean): SyncStrategyPlan;
     compileProjectCode(request: CompileProjectCodeRequest): Promise<CompileProjectCodeResult>;
+    killEditorProcess(): Promise<{
+        killed: boolean;
+        error?: string;
+    }>;
     launchEditor(request: LaunchEditorRequest): Promise<LaunchEditorResult>;
     waitForEditorRestart(probeConnection: ProbeConnection, options?: {
         disconnectTimeoutMs?: number;
@@ -131,6 +136,10 @@ export declare class ProjectController implements ProjectControllerLike {
     get liveCodingSupported(): boolean;
     classifyChangedPaths(changedPaths: string[], forceRebuild?: boolean): SyncStrategyPlan;
     compileProjectCode(request: CompileProjectCodeRequest): Promise<CompileProjectCodeResult>;
+    killEditorProcess(): Promise<{
+        killed: boolean;
+        error?: string;
+    }>;
     launchEditor(request: LaunchEditorRequest): Promise<LaunchEditorResult>;
     waitForEditorRestart(probeConnection: ProbeConnection, options?: {
         disconnectTimeoutMs?: number;

package/dist/project-controller.js

@@ -1,4 +1,4 @@
-import { spawn } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
 import { access, readdir, unlink } from 'node:fs/promises';
 import { constants as fsConstants } from 'node:fs';
 import { dirname, resolve } from 'node:path';
@@ -358,6 +358,7 @@ export class ProjectController {
             },
             durationMs: Date.now() - startedAt,
             exitCode: completed.exitCode,
+            compilationSucceeded: completed.exitCode === 0,
             restartRequired: true,
             restartReasons: ['external_build_completed'],
             outputIncluded: includeOutput,
@@ -380,9 +381,26 @@ export class ProjectController {
             if (classification.lockedFiles.length > 0) {
                 result.lockedFiles = classification.lockedFiles;
             }
+            // Compilation itself succeeded if the failure is only at the link/lock stage
+            result.compilationSucceeded = classification.errorCategory === 'locked_file'
+                || classification.errorCategory === 'link';
         }
         return result;
     }
+    async killEditorProcess() {
+        try {
+            if (this.platform === 'win32') {
+                execSync('taskkill /F /IM "UnrealEditor.exe"', { timeout: 10000 });
+            }
+            else {
+                execSync('pkill -9 -f UnrealEditor', { timeout: 10000 });
+            }
+            return { killed: true };
+        }
+        catch (err) {
+            return { killed: false, error: String(err) };
+        }
+    }
     async launchEditor(request) {
         const engineRoot = request.engineRoot ?? this.env.UE_ENGINE_ROOT;
         const projectPath = request.projectPath ?? this.env.UE_PROJECT_PATH;

package/dist/prompts/prompt-catalog.js

@@ -218,7 +218,7 @@ export const promptCatalog = {
             `Author widget motion for ${widget_asset_path} using animation '${animation_name}'.`,
             formatPromptBlock('design_spec_json', design_spec_json, 'A design_spec_json with motion data is required.'),
             formatPromptList('Compare reference paths', compare_reference_paths, 'No compare reference paths were supplied. Use checkpoint frames from the design spec if they exist.'),
-            'Use create_widget_animation or modify_widget_animation instead of overloading modify_widget_blueprint.',
+            'Use create_widget_animation or modify_widget_animation instead of overloading widget tools. Use patch_widget for property changes and replace_widget_tree for full tree replacement.',
             'Supported track subset: render_opacity, render_transform_translation, render_transform_scale, render_transform_angle, color_and_opacity.',
             'Prefer widget_path selectors for bindings and tracks. Accept widget_name only as a compatibility fallback when unique.',
             'Use replace_timeline as the canonical write path. patch_metadata is only for display labels, checkpoints, playback metadata, and other non-track updates.',
@@ -263,7 +263,7 @@ export const promptCatalog = {
             `Target widget class: ${widget_class_path}.`,
             `Class default property: ${class_default_property}.`,
             'Inspect the current Blueprint members and class defaults first.',
-            'Return the smallest set of modify_blueprint_members or modify_widget_blueprint.patch_class_defaults calls needed to complete the wiring.',
+            'Return the smallest set of modify_blueprint_members or patch_widget_class_defaults calls needed to complete the wiring.',
         ].join('\n'),
     },
     debug_widget_compile_errors: {

package/dist/register-server-tools.d.ts

@@ -26,7 +26,8 @@ type RegisterServerToolsOptions = {
     getLastExternalBuildContext: () => Record<string, unknown> | null;
     clearProjectAutomationContext: () => void;
     getToolHelpEntry: (toolName: string) => ToolHelpEntry | undefined;
+    toolHelpRegistry: Map<string, ToolHelpEntry>;
     editorPollIntervalMs: number;
 };
-export declare function registerServerTools({ server, client, projectController, automationController, callSubsystemJson, resolveProjectInputs, getProjectAutomationContext, rememberExternalBuild, getLastExternalBuildContext, clearProjectAutomationContext, getToolHelpEntry, editorPollIntervalMs, }: RegisterServerToolsOptions): void;
+export declare function registerServerTools({ server, client, projectController, automationController, callSubsystemJson, resolveProjectInputs, getProjectAutomationContext, rememberExternalBuild, getLastExternalBuildContext, clearProjectAutomationContext, getToolHelpEntry, toolHelpRegistry, editorPollIntervalMs, }: RegisterServerToolsOptions): void;
 export {};

package/dist/register-server-tools.js

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { exampleCatalog } from './catalogs/example-catalog.js';
 import { collectRelatedResources, collectToolExampleFamilies as collectToolExampleFamiliesFromCatalog, summarizeOutputSchema, summarizeSchemaFields, } from './helpers/tool-help.js';
-import { AnimMontageMutationOperationSchema, AnimationNotifySelectorSchema, AnimSequenceMutationOperationSchema, BehaviorTreeMutationOperationSchema, BehaviorTreeNodeSelectorSchema, BlackboardKeySchema, BlackboardMutationOperationSchema, BlendParameterSchema, BlendSpaceMutationOperationSchema, BlendSpaceSampleSchema, BlueprintGraphMutationOperationSchema, BlueprintMemberMutationOperationSchema, BuildConfigurationSchema, BuildPlatformSchema, CurveChannelSchema, CurveKeyDeleteSchema, CurveKeyUpsertSchema, CurveTableModeSchema, CurveTableRowSchema, CurveTypeSchema, DataTableRowSchema, ExtractAssetTypeSchema, EnhancedInputValueTypeSchema, FontImportItemSchema, ImportJobListSchema, ImportJobSchema, ImportPayloadSchema, InputMappingSchema, JsonObjectSchema, MaterialConnectionSelectorFieldsSchema, MaterialFontParameterSchema, MaterialFunctionAssetKindSchema, MaterialGraphOperationKindSchema, MaterialGraphOperationSchema, MaterialGraphPayloadSchema, MaterialLayerStackSchema, MaterialNodePositionSchema, MaterialScalarParameterSchema, MaterialStaticSwitchParameterSchema, MaterialTextureParameterSchema, MaterialVectorParameterSchema, MeshImportPayloadSchema, StateTreeEditorNodeSelectorSchema, StateTreeMutationOperationSchema, StateTreeStateSelectorSchema, StateTreeTransitionSelectorSchema, StateTreeBindingSchema, TextureImportPayloadSchema, UserDefinedEnumEntrySchema, UserDefinedEnumMutationOperationSchema, UserDefinedStructFieldSchema, UserDefinedStructMutationOperationSchema, WidgetBlueprintMutationOperationSchema, WidgetNodeSchema, WidgetSelectorFieldsSchema, WindowFontApplicationSchema, } from './schemas/tool-inputs.js';
+import { AnimMontageMutationOperationSchema, AnimationNotifySelectorSchema, AnimSequenceMutationOperationSchema, BehaviorTreeMutationOperationSchema, BehaviorTreeNodeSelectorSchema, BlackboardKeySchema, BlackboardMutationOperationSchema, BlendParameterSchema, BlendSpaceMutationOperationSchema, BlendSpaceSampleSchema, BlueprintGraphMutationOperationSchema, BlueprintMemberMutationOperationSchema, BuildConfigurationSchema, BuildPlatformSchema, CurveChannelSchema, CurveKeyDeleteSchema, CurveKeyUpsertSchema, CurveTableModeSchema, CurveTableRowSchema, CurveTypeSchema, DataTableRowSchema, ExtractAssetTypeSchema, EnhancedInputValueTypeSchema, FontImportItemSchema, ImportJobListSchema, ImportJobSchema, ImportPayloadSchema, InputMappingSchema, JsonObjectSchema, MaterialConnectionSelectorFieldsSchema, MaterialFontParameterSchema, MaterialFunctionAssetKindSchema, MaterialGraphOperationKindSchema, MaterialGraphOperationSchema, MaterialGraphPayloadSchema, MaterialLayerStackSchema, MaterialNodePositionSchema, MaterialScalarParameterSchema, MaterialStaticSwitchParameterSchema, MaterialTextureParameterSchema, MaterialVectorParameterSchema, MeshImportOptionsSchema, MeshImportPayloadSchema, StateTreeEditorNodeSelectorSchema, StateTreeMutationOperationSchema, StateTreeStateSelectorSchema, StateTreeTransitionSelectorSchema, StateTreeBindingsObjectSchema, TextureImportOptionsSchema, TextureImportPayloadSchema, UserDefinedEnumEntrySchema, UserDefinedEnumMutationOperationSchema, UserDefinedStructFieldSchema, UserDefinedStructMutationOperationSchema, WidgetBlueprintMutationOperationSchema, WidgetNodeSchema, WidgetSelectorFieldsSchema, WindowFontApplicationSchema, } from './schemas/tool-inputs.js';
 import { applyWindowUiChangesResultSchema, AutomationRunListSchema, automationRunSchema, CaptureResultSchema, CascadeResultSchema, CleanupCapturesResultSchema, CompareCaptureResultSchema, CompareMotionCaptureBundleResultSchema, CreateModifyWidgetAnimationResultSchema, ExtractWidgetAnimationResultSchema, ListCapturesResultSchema, motionCaptureModeSchema, MotionCaptureBundleResultSchema, widgetAnimationCheckpointSchema, } from './schemas/tool-results.js';
 import { registerAnimationAuthoringTools } from './tools/animation-authoring.js';
 import { registerAutomationRunTools } from './tools/automation-runs.js';
 import { registerBlueprintAuthoringTools } from './tools/blueprint-authoring.js';
+import { registerCompositeTools } from './tools/composite-tools.js';
 import { registerCommonUIButtonStyleTools } from './tools/commonui-button-style.js';
 import { registerDataAndInputTools } from './tools/data-and-input.js';
 import { registerExtractionTools } from './tools/extraction.js';
@@ -29,7 +30,7 @@ const scopeEnum = z.enum([
     'Full',
     'FullWithBytecode',
 ]);
-export function registerServerTools({ server, client, projectController, automationController, callSubsystemJson, resolveProjectInputs, getProjectAutomationContext, rememberExternalBuild, getLastExternalBuildContext, clearProjectAutomationContext, getToolHelpEntry, editorPollIntervalMs, }) {
+export function registerServerTools({ server, client, projectController, automationController, callSubsystemJson, resolveProjectInputs, getProjectAutomationContext, rememberExternalBuild, getLastExternalBuildContext, clearProjectAutomationContext, getToolHelpEntry, toolHelpRegistry, editorPollIntervalMs, }) {
     const collectToolExampleFamilies = (toolName) => (collectToolExampleFamiliesFromCatalog(exampleCatalog, toolName));
     registerExtractionTools({
         server,
@@ -37,6 +38,7 @@ export function registerServerTools({ server, client, projectController, automat
         scopeEnum,
         extractAssetTypeSchema: ExtractAssetTypeSchema,
         cascadeResultSchema: CascadeResultSchema,
+        toolHelpRegistry,
     });
     registerWidgetStructureTools({
         server,
@@ -112,6 +114,7 @@ export function registerServerTools({ server, client, projectController, automat
         materialGraphOperationKindSchema: MaterialGraphOperationKindSchema,
         materialGraphOperationSchema: MaterialGraphOperationSchema,
         materialFunctionAssetKindSchema: MaterialFunctionAssetKindSchema,
+        toolHelpRegistry,
     });
     registerAutomationRunTools({
         server,
@@ -166,7 +169,7 @@ export function registerServerTools({ server, client, projectController, automat
         stateTreeStateSelectorSchema: StateTreeStateSelectorSchema,
         stateTreeEditorNodeSelectorSchema: StateTreeEditorNodeSelectorSchema,
         stateTreeTransitionSelectorSchema: StateTreeTransitionSelectorSchema,
-        stateTreeBindingSchema: StateTreeBindingSchema,
+        stateTreeBindingsObjectSchema: StateTreeBindingsObjectSchema,
     });
     registerAnimationAuthoringTools({
         server,
@@ -194,6 +197,14 @@ export function registerServerTools({ server, client, projectController, automat
         importJobListSchema: ImportJobListSchema,
         textureImportPayloadSchema: TextureImportPayloadSchema,
         meshImportPayloadSchema: MeshImportPayloadSchema,
+        textureImportOptionsSchema: TextureImportOptionsSchema,
+        meshImportOptionsSchema: MeshImportOptionsSchema,
+        toolHelpRegistry,
+    });
+    registerCompositeTools({
+        server,
+        callSubsystemJson,
+        toolHelpRegistry,
     });
     registerUtilityTools({
         server,

package/dist/resources/static-doc-resources.js

@@ -64,7 +64,8 @@ export function registerStaticDocResources(server) {
         '- UserDefinedEnum: entry selector by name; operations replace_entries, rename_entry, remove_entry, reorder_entries.',
         '- Blackboard: key selector by entryName; operations replace_keys, patch_key, remove_key, set_parent.',
         '- BehaviorTree: node selector by nodePath; operations replace_tree, patch_node, patch_attachment, set_blackboard.',
-        '- StateTree: selectors by stateId/statePath, editorNodeId, or transitionId; operations replace_tree, patch_state, patch_editor_node, patch_transition, set_schema.',
+        '- StateTree: selectors by stateId/statePath, editorNodeId, or transitionId; operations replace_tree, patch_state, patch_editor_node, patch_transition, set_schema, set_bindings, add_binding, remove_binding. Blueprint-wrapped nodes (StateTreeBlueprintTaskWrapper / StateTreeBlueprintConditionWrapper) require instanceObjectClass for the backing instance to exist at runtime.',
+        '- StateTree property bindings wire task/evaluator outputs to task inputs. Use extract_asset to discover structIds and property names. Each binding has sourcePath and targetPath with segments: [{name, arrayIndex?, instanceStruct?}] and optional structId. Operations: set_bindings (replace all), add_binding (append), remove_binding (by targetPath). In replace_tree/create: include as { bindings: { propertyBindings: [...] } }.',
         '- AnimSequence: notify selector by notifyId/notifyGuid with notifyIndex or track metadata as fallback; operations replace_notifies, patch_notify, replace_sync_markers, replace_curve_metadata.',
         '- AnimMontage: notify selector by notifyId/notifyGuid with notifyIndex or track metadata as fallback; operations replace_notifies, patch_notify, replace_sections, replace_slots.',
         '- BlendSpace: sample selector by sampleIndex; operations replace_samples, patch_sample, set_axes.',