blueprint-extractor-mcp 3.0.1 → 3.2.0

package/dist/helpers/project-resolution.js

@@ -1,3 +1,6 @@
+import { access } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { resolve } from 'node:path';
 export function rememberExternalBuild(result) {
     return {
         success: result.success === true,
@@ -27,6 +30,31 @@ export async function getProjectAutomationContext(deps) {
     setCachedContext(nextContext);
     return nextContext;
 }
+let cachedHeuristicEngineRoot;
+const HEURISTIC_ENGINE_CANDIDATES = [
+    'C:/Program Files/Epic Games/UE_5.6',
+    'C:/Program Files/Epic Games/UE_5.5',
+    'C:/Program Files/Epic Games/UE_5.4',
+    'C:/Program Files/Epic Games/UE_5.3',
+];
+const ENGINE_MARKER = 'Engine/Build/BatchFiles/Build.bat';
+async function probeEngineRootHeuristic() {
+    if (cachedHeuristicEngineRoot !== undefined) {
+        return cachedHeuristicEngineRoot || undefined;
+    }
+    for (const candidate of HEURISTIC_ENGINE_CANDIDATES) {
+        try {
+            await access(resolve(candidate, ENGINE_MARKER), fsConstants.F_OK);
+            cachedHeuristicEngineRoot = candidate;
+            return candidate;
+        }
+        catch {
+            // not found, try next
+        }
+    }
+    cachedHeuristicEngineRoot = '';
+    return undefined;
+}
 export async function resolveProjectInputs(request, deps) {
     const { getProjectAutomationContext, firstDefinedString, env = process.env, } = deps;
     let context = null;
@@ -45,7 +73,28 @@ export async function resolveProjectInputs(request, deps) {
     const engineRootFromEnv = firstDefinedString(env.UE_ENGINE_ROOT);
     const projectPathFromEnv = firstDefinedString(env.UE_PROJECT_PATH);
     const targetFromEnv = firstDefinedString(env.UE_PROJECT_TARGET, env.UE_EDITOR_TARGET);
-    const engineRoot = firstDefinedString(request.engine_root, engineRootFromContext, engineRootFromEnv);
+    let engineRoot = firstDefinedString(request.engine_root, engineRootFromContext, engineRootFromEnv);
+    let engineRootSource;
+    if (request.engine_root) {
+        engineRootSource = 'explicit';
+    }
+    else if (engineRootFromContext) {
+        engineRootSource = 'editor_context';
+    }
+    else if (engineRootFromEnv) {
+        engineRootSource = 'environment';
+    }
+    else {
+        // Filesystem heuristic: probe common UE installation paths
+        const heuristicRoot = await probeEngineRootHeuristic();
+        if (heuristicRoot) {
+            engineRoot = heuristicRoot;
+            engineRootSource = 'filesystem_heuristic';
+        }
+        else {
+            engineRootSource = 'missing';
+        }
+    }
     const projectPath = firstDefinedString(request.project_path, projectPathFromContext, projectPathFromEnv);
     const target = firstDefinedString(request.target, targetFromContext, targetFromEnv);
     return {
@@ -55,7 +104,7 @@ export async function resolveProjectInputs(request, deps) {
         context,
         contextError,
         sources: {
-            engineRoot: request.engine_root ? 'explicit' : engineRootFromContext ? 'editor_context' : engineRootFromEnv ? 'environment' : 'missing',
+            engineRoot: engineRootSource,
             projectPath: request.project_path ? 'explicit' : projectPathFromContext ? 'editor_context' : projectPathFromEnv ? 'environment' : 'missing',
             target: request.target ? 'explicit' : targetFromContext ? 'editor_context' : targetFromEnv ? 'environment' : 'missing',
         },

package/dist/helpers/subsystem.d.ts

@@ -1,13 +1,29 @@
 import type { CallToolResult, ContentBlock } from '@modelcontextprotocol/sdk/types.js';
+export interface SubsystemCallOptions {
+    timeoutMs?: number;
+}
 type SubsystemClientLike = {
-    callSubsystem(method: string, params: Record<string, unknown>): Promise<string>;
+    callSubsystem(method: string, params: Record<string, unknown>, options?: SubsystemCallOptions): Promise<string>;
 };
-export declare function callSubsystemJson(client: SubsystemClientLike, method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function callSubsystemJson(client: SubsystemClientLike, method: string, params: Record<string, unknown>, options?: SubsystemCallOptions): Promise<Record<string, unknown>>;
 export declare function jsonToolSuccess(parsed: unknown, options?: {
     extraContent?: ContentBlock[];
 }): CallToolResult & {
     structuredContent: Record<string, unknown>;
 };
+/**
+ * Strips the C++ 'F' prefix from USTRUCT script paths.
+ * UE registers USTRUCTs without the F prefix in script paths.
+ * e.g., /Script/Module.FSTCFoo → /Script/Module.STCFoo
+ *
+ * Only strips when the class name starts with F followed by an uppercase letter,
+ * matching the UE USTRUCT naming convention.
+ */
+export declare function normalizeUStructPath(path: string): string;
+export declare function normalizeUStructPaths(paths: string[]): {
+    normalized: string[];
+    warnings: string[];
+};
 export declare function jsonToolError(e: unknown): {
     content: {
         type: "text";

package/dist/helpers/subsystem.js

@@ -1,19 +1,90 @@
 import { isRecord } from './formatting.js';
-export async function callSubsystemJson(client, method, params) {
-    const result = await client.callSubsystem(method, params);
+export async function callSubsystemJson(client, method, params, options) {
+    const result = await client.callSubsystem(method, params, options);
+    if (process.env.MCP_DEBUG_RESPONSES) {
+        process.stderr.write(`[MCP_DEBUG] ${method} raw response: ${result}\n`);
+    }
     const parsed = JSON.parse(result);
     if (typeof parsed.error === 'string' && parsed.error.length > 0) {
-        throw new Error(parsed.error);
+        const err = new Error(parsed.error);
+        err.ueResponse = parsed;
+        throw err;
+    }
+    // Check for error-only failure responses (success: false with an explicit error message
+    // but no business-level fields). Structured responses with success: false are passed
+    // through so tool code can inspect them for orchestration (e.g., fallback strategies).
+    if (parsed.success === false) {
+        const explicitMessage = parsed.message ?? parsed.errorMessage;
+        if (typeof explicitMessage === 'string' && explicitMessage.length > 0) {
+            const err = new Error(explicitMessage);
+            err.ueResponse = parsed;
+            throw err;
+        }
+    }
+    // Catch structured error responses with diagnostics but no explicit message.
+    // These come from FAssetMutationContext.BuildResult(false) in the C++ plugin.
+    if (parsed.success === false
+        && 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);
+        const synthesized = messages.length > 0
+            ? messages.join('; ')
+            : `Operation failed with ${parsed.diagnostics.length} diagnostic(s)`;
+        const err = new Error(synthesized);
+        err.ueResponse = parsed;
+        throw err;
+    }
+    if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
+        const firstError = parsed.errors[0];
+        const err = new Error(typeof firstError === 'string' ? firstError : JSON.stringify(firstError));
+        err.ueResponse = parsed;
+        throw err;
+    }
+    if (Object.keys(parsed).length === 0) {
+        throw new Error('Empty response from subsystem');
     }
     return parsed;
 }
 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) {
+        return {
+            content: [{ type: 'text', text: `Error: ${typeof parsed.message === 'string' ? parsed.message : 'Operation failed'}` }],
+            structuredContent,
+            isError: true,
+        };
+    }
     return {
         content: options.extraContent ? [...options.extraContent] : [],
         structuredContent,
     };
 }
+/**
+ * Strips the C++ 'F' prefix from USTRUCT script paths.
+ * UE registers USTRUCTs without the F prefix in script paths.
+ * e.g., /Script/Module.FSTCFoo → /Script/Module.STCFoo
+ *
+ * Only strips when the class name starts with F followed by an uppercase letter,
+ * matching the UE USTRUCT naming convention.
+ */
+export function normalizeUStructPath(path) {
+    return path.replace(/^(\/Script\/[^.]+\.)F([A-Z])/, '$1$2');
+}
+export function normalizeUStructPaths(paths) {
+    const warnings = [];
+    const normalized = paths.map(p => {
+        const result = normalizeUStructPath(p);
+        if (result !== p) {
+            warnings.push(`Auto-normalized F-prefix: "${p}" → "${result}"`);
+        }
+        return result;
+    });
+    return { normalized, warnings };
+}
 export function jsonToolError(e) {
     return {
         content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }],

package/dist/helpers/tool-results.js

@@ -65,9 +65,25 @@ export function createToolResultNormalizers({ taskAwareTools, classifyRecoverabl
         const diagnostics = Array.isArray(payload.diagnostics)
             ? payload.diagnostics
             : [];
+        // Merge diagnostics from ueResponse if the error carries one (set by callSubsystemJson).
+        if (diagnostics.length === 0
+            && payloadOrError instanceof Error
+            && isRecord(payloadOrError.ueResponse)) {
+            const ueResp = payloadOrError.ueResponse;
+            if (Array.isArray(ueResp.diagnostics)) {
+                diagnostics.push(...ueResp.diagnostics);
+            }
+        }
         const firstDiagnostic = diagnostics.find((candidate) => (isRecord(candidate)
             && typeof candidate.message === 'string'
             && candidate.message.length > 0));
+        const existingContentText = existingResult
+            && Array.isArray(existingResult.content)
+            && isRecord(existingResult.content[0])
+            && existingResult.content[0].type === 'text'
+            && typeof existingResult.content[0].text === 'string'
+            ? existingResult.content[0].text.replace(/^Error:\s*/, '')
+            : undefined;
         const message = typeof payload.message === 'string'
             ? payload.message.replace(/^Error:\s*/, '')
             : typeof payload.error === 'string'
@@ -78,7 +94,26 @@ export function createToolResultNormalizers({ taskAwareTools, classifyRecoverabl
                         ? payloadOrError.message
                         : typeof payloadOrError === 'string'
                             ? payloadOrError.replace(/^Error:\s*/, '')
-                            : `Tool '${toolName}' failed.`;
+                            : typeof existingContentText === 'string'
+                                ? existingContentText
+                                : payloadOrError == null
+                                    ? `Tool '${toolName}' failed with no error details (received ${String(payloadOrError)})`
+                                    : (() => {
+                                        const type = payloadOrError?.constructor?.name ?? typeof payloadOrError;
+                                        const keys = isRecord(payloadOrError) ? Object.keys(payloadOrError).join(', ') : '';
+                                        const truncatedJson = (() => {
+                                            try {
+                                                const s = JSON.stringify(payloadOrError);
+                                                return s.length > 500 ? s.slice(0, 500) + '…' : s;
+                                            }
+                                            catch {
+                                                return '[unserializable]';
+                                            }
+                                        })();
+                                        return keys
+                                            ? `Tool '${toolName}' failed — received ${type} with keys [${keys}]: ${truncatedJson}`
+                                            : `Tool '${toolName}' failed — received ${type}: ${truncatedJson}`;
+                                    })();
         const classification = classifyRecoverableToolFailure(toolName, message);
         const envelope = {
             ...payload,

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

@@ -4,7 +4,9 @@ import { type ToolHelpEntry } from './helpers/tool-help.js';
 import type { ProjectControllerLike, CompileProjectCodeResult } from './project-controller.js';
 import type { ProjectAutomationContext, ResolvedProjectInputs } from './tool-context.js';
 import { UEClient } from './ue-client.js';
-type JsonSubsystemCaller = (method: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+type JsonSubsystemCaller = (method: string, params: Record<string, unknown>, options?: {
+    timeoutMs?: number;
+}) => Promise<Record<string, unknown>>;
 type UEClientLike = Pick<UEClient, 'callSubsystem'> & Partial<Pick<UEClient, 'checkConnection'>>;
 type ResolveProjectInputsFn = (request: {
     engine_root?: string;

package/dist/register-server-tools.js

@@ -1,7 +1,7 @@
 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, 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, MeshImportPayloadSchema, StateTreeEditorNodeSelectorSchema, StateTreeMutationOperationSchema, StateTreeStateSelectorSchema, StateTreeTransitionSelectorSchema, StateTreeBindingSchema, 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';
@@ -166,6 +166,7 @@ export function registerServerTools({ server, client, projectController, automat
         stateTreeStateSelectorSchema: StateTreeStateSelectorSchema,
         stateTreeEditorNodeSelectorSchema: StateTreeEditorNodeSelectorSchema,
         stateTreeTransitionSelectorSchema: StateTreeTransitionSelectorSchema,
+        stateTreeBindingSchema: StateTreeBindingSchema,
     });
     registerAnimationAuthoringTools({
         server,

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

@@ -68,7 +68,7 @@ export function registerStaticDocResources(server) {
         '- 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.',
-        '- Blueprint members: selectors by variableName, componentName, and functionName; operations replace_variables, patch_variable, replace_components, patch_component, replace_function_stubs, patch_class_defaults, compile.',
+        '- Blueprint members: selectors by variableName, componentName, and functionName; operations replace_variables, patch_variable, replace_components, patch_component, add_component, replace_function_stubs, patch_class_defaults, compile.',
         '- Blueprint graphs: operation upsert_function_graphs preserves unrelated graphs; append_function_call_to_sequence patches an existing sequence-style initializer without replacing the whole graph.',
         '',
         'WidgetBlueprint guidance:',

package/dist/schemas/tool-inputs.d.ts

@@ -3038,7 +3038,7 @@ export declare const StateTreeMutationOperationSchema: z.ZodEnum<["replace_tree"
 export declare const AnimSequenceMutationOperationSchema: z.ZodEnum<["replace_notifies", "patch_notify", "replace_sync_markers", "replace_curve_metadata"]>;
 export declare const AnimMontageMutationOperationSchema: z.ZodEnum<["replace_notifies", "patch_notify", "replace_sections", "replace_slots"]>;
 export declare const BlendSpaceMutationOperationSchema: z.ZodEnum<["replace_samples", "patch_sample", "set_axes"]>;
-export declare const BlueprintMemberMutationOperationSchema: z.ZodEnum<["replace_variables", "patch_variable", "replace_components", "patch_component", "replace_function_stubs", "patch_class_defaults", "compile"]>;
+export declare const BlueprintMemberMutationOperationSchema: z.ZodEnum<["replace_variables", "patch_variable", "replace_components", "patch_component", "add_component", "replace_function_stubs", "patch_class_defaults", "compile"]>;
 export declare const BlueprintGraphMutationOperationSchema: z.ZodEnum<["upsert_function_graphs", "append_function_call_to_sequence", "compile"]>;
 export declare const UserDefinedStructFieldSchema: z.ZodObject<{
     guid: z.ZodOptional<z.ZodString>;
@@ -3146,6 +3146,22 @@ export declare const StateTreeTransitionSelectorSchema: z.ZodObject<{
     transitionId: z.ZodOptional<z.ZodString>;
     id: z.ZodOptional<z.ZodString>;
 }, z.ZodTypeAny, "passthrough">>;
+export declare const StateTreeBindingSchema: z.ZodObject<{
+    sourceTask: z.ZodString;
+    sourceProperty: z.ZodString;
+    targetTask: z.ZodString;
+    targetProperty: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    sourceTask: string;
+    sourceProperty: string;
+    targetTask: string;
+    targetProperty: string;
+}, {
+    sourceTask: string;
+    sourceProperty: string;
+    targetTask: string;
+    targetProperty: string;
+}>;
 export declare const AnimationNotifySelectorSchema: z.ZodObject<{
     notifyId: z.ZodOptional<z.ZodString>;
     notifyGuid: z.ZodOptional<z.ZodString>;

package/dist/schemas/tool-inputs.js

@@ -359,6 +359,7 @@ export const BlueprintMemberMutationOperationSchema = z.enum([
     'patch_variable',
     'replace_components',
     'patch_component',
+    'add_component',
     'replace_function_stubs',
     'patch_class_defaults',
     'compile',
@@ -408,6 +409,12 @@ export const StateTreeTransitionSelectorSchema = z.object({
     transitionId: z.string().optional(),
     id: z.string().optional(),
 }).passthrough();
+export const StateTreeBindingSchema = z.object({
+    sourceTask: z.string().describe('Name of the source task whose output provides the value'),
+    sourceProperty: z.string().describe('Property name on the source task to read from'),
+    targetTask: z.string().describe('Name of the target task whose input receives the value'),
+    targetProperty: z.string().describe('Property name on the target task to write to'),
+}).describe('Task output-to-input binding (requires C++ plugin support — not yet implemented)');
 export const AnimationNotifySelectorSchema = z.object({
     notifyId: z.string().optional(),
     notifyGuid: z.string().optional(),

package/dist/server-config.js

@@ -69,5 +69,50 @@ export function classifyRecoverableToolFailure(toolName, message) {
             ],
         };
     }
+    if (message.includes('timed out') || message.includes('timeout') || message.includes('ETIMEDOUT') || message.includes('ESOCKETTIMEDOUT')) {
+        return {
+            code: 'timeout',
+            recoverable: true,
+            retry_after_ms: 5000,
+            next_steps: [
+                'Retry with simpler payload or increase timeout',
+                'Check if UE editor is responding (call wait_for_editor)',
+                'For StateTree tools, try splitting complex payloads into multiple calls',
+            ],
+        };
+    }
+    if (message.includes('JSON') || message.includes('Unexpected token') || message.includes('SyntaxError')) {
+        return {
+            code: 'invalid_response',
+            recoverable: true,
+            next_steps: [
+                'Check UE editor output log for errors',
+                'The editor may have returned an HTML error page instead of JSON',
+                'Retry the operation — this may be a transient serialization issue',
+            ],
+        };
+    }
+    if (message.includes('locked by another process') || message.includes('locked file') || message.includes('cannot access the file')) {
+        return {
+            code: 'locked_file',
+            recoverable: true,
+            next_steps: [
+                'Close UE editor to release DLL locks',
+                'Call restart_editor, then retry the build',
+                'If editor was just restarted, the cached build may apply automatically',
+            ],
+        };
+    }
+    if (message.includes('Empty response') || message.includes('empty response') || message === '') {
+        return {
+            code: 'empty_response',
+            recoverable: true,
+            next_steps: [
+                'Verify the asset path exists',
+                'Check editor connection with wait_for_editor',
+                'The UE subsystem may have crashed — check editor logs',
+            ],
+        };
+    }
     return null;
 }

package/dist/server-factory.js

@@ -17,7 +17,7 @@ export function createBlueprintExtractorServer(client = new UEClient(), projectC
     const toolHelpRegistry = new Map();
     const server = new McpServer({
         name: 'blueprint-extractor',
-        version: '3.0.1',
+        version: '3.1.0',
     }, {
         instructions: serverInstructions,
     });
@@ -32,7 +32,7 @@ export function createBlueprintExtractorServer(client = new UEClient(), projectC
         normalizeToolError,
         normalizeToolSuccess,
     });
-    const callSubsystemJson = (method, params) => (callSubsystemJsonWithClient(client, method, params));
+    const callSubsystemJson = (method, params, options) => (callSubsystemJsonWithClient(client, method, params, options));
     function rememberExternalBuild(result) {
         lastExternalBuildContext = buildExternalBuildContext(result);
     }

package/dist/tool-context.d.ts

@@ -14,7 +14,7 @@ export type ProjectAutomationContext = {
     liveCodingStarted?: boolean;
     liveCodingError?: string;
 };
-export type ProjectInputSource = 'explicit' | 'editor_context' | 'environment' | 'missing';
+export type ProjectInputSource = 'explicit' | 'editor_context' | 'environment' | 'filesystem_heuristic' | 'missing';
 export type ResolvedProjectInputs = {
     engineRoot?: string;
     projectPath?: string;