@openfairygui/mcp 0.2.0-alpha.0

package/dist/stdio-ByGWerIG.mjs

@@ -0,0 +1,470 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BackendRuntime } from "@openfairygui/backend";
+import { z } from "zod";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { pathToFileURL } from "node:url";
+//#region src/prompt-definitions.ts
+const OPENFAIRYGUI_BACKEND_PROMPT_NAMES = [
+	"openfairygui_inspect_capabilities",
+	"openfairygui_open_and_inspect_session",
+	"openfairygui_plan_revision_checked_transaction",
+	"openfairygui_save_session",
+	"openfairygui_poll_runtime_state"
+];
+const OPENFAIRYGUI_BACKEND_PROMPT_DEFINITIONS = [
+	{
+		name: "openfairygui_inspect_capabilities",
+		title: "Inspect OpenFairyGUI Backend Capabilities",
+		description: "Guide a client through the capability and version discovery tool.",
+		text: [
+			"Use openfairygui_backend_get_capabilities first.",
+			"Read contractVersion, capabilitySchemaVersion, capability planes, methods, and runtime non-goals from the backend envelope.",
+			"Do not infer artifact publish/restore, subscriptions, persistent jobs, or cache source-of-truth support when the backend marks them unsupported."
+		].join("\n")
+	},
+	{
+		name: "openfairygui_open_and_inspect_session",
+		title: "Open and Inspect an OpenFairyGUI Session",
+		description: "Guide a client through opening and reading a backend session.",
+		text: [
+			"Use openfairygui_backend_open_session with a projectPath, then use openfairygui_backend_get_session with the returned sessionId.",
+			"Backend path policy remains authoritative for project paths and save targets; MCP roots are only client context in this package.",
+			"Close the session with openfairygui_backend_close_session when finished."
+		].join("\n")
+	},
+	{
+		name: "openfairygui_plan_revision_checked_transaction",
+		title: "Plan a Revision-Checked OpenFairyGUI Transaction",
+		description: "Guide a client through backend-owned revision checks without inventing operation grammar.",
+		text: [
+			"Use openfairygui_backend_get_session to read the current revision before mutation.",
+			"Call openfairygui_backend_apply_transaction with sessionId, expectedRevision, and backend/UAM-owned operations.",
+			"If the backend returns a stale revision error, refresh the session snapshot and re-plan against the new revision.",
+			"Do not invent selector grammar, transaction grammar, or operation payload semantics at the MCP layer."
+		].join("\n")
+	},
+	{
+		name: "openfairygui_save_session",
+		title: "Save an OpenFairyGUI Backend Session",
+		description: "Guide a client through coordinated backend save semantics.",
+		text: [
+			"Use openfairygui_backend_save_session with sessionId and expectedRevision when available.",
+			"Backend path policy remains authoritative for targetPath; MCP does not canonicalize or authorize paths.",
+			"Handle stale revision and partial save failure envelopes from the backend without rewriting their error semantics."
+		].join("\n")
+	},
+	{
+		name: "openfairygui_poll_runtime_state",
+		title: "Poll OpenFairyGUI Runtime State",
+		description: "Guide a client through event, job, and cache polling tools.",
+		text: [
+			"Use openfairygui_backend_get_events for polling events with the backend cursor contract.",
+			"Use openfairygui_backend_list_jobs and openfairygui_backend_get_job for in-memory job snapshots.",
+			"Use openfairygui_backend_get_cache_snapshot and openfairygui_backend_refresh_cache for derived read-only cache state.",
+			"Subscriptions, persistent jobs, artifact jobs, and cache-as-source-of-truth behavior are not supported by backend P2."
+		].join("\n")
+	}
+];
+function promptResult(text) {
+	return { messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text
+		}
+	}] };
+}
+function registerOpenFairyGuiBackendPrompts(server) {
+	for (const definition of OPENFAIRYGUI_BACKEND_PROMPT_DEFINITIONS) server.registerPrompt(definition.name, {
+		title: definition.title,
+		description: definition.description
+	}, () => promptResult(definition.text));
+}
+//#endregion
+//#region src/resource-definitions.ts
+const JSON_MIME_TYPE = "application/json";
+function firstVariable(value) {
+	return Array.isArray(value) ? value[0] ?? "" : value ?? "";
+}
+function jsonResource(uri, backendResult) {
+	return { contents: [{
+		uri: uri.toString(),
+		mimeType: JSON_MIME_TYPE,
+		text: JSON.stringify(backendResult, null, 2)
+	}] };
+}
+const OPENFAIRYGUI_BACKEND_CAPABILITIES_RESOURCE_URI = "openfairygui://backend/capabilities";
+const OPENFAIRYGUI_BACKEND_RESOURCE_TEMPLATES = [
+	"openfairygui://backend/session/{sessionId}",
+	"openfairygui://backend/cache/{sessionId}",
+	"openfairygui://backend/job/{sessionId}/{jobId}"
+];
+function registerOpenFairyGuiBackendResources(server, runtime) {
+	server.registerResource("openfairygui_backend_capabilities", OPENFAIRYGUI_BACKEND_CAPABILITIES_RESOURCE_URI, {
+		title: "OpenFairyGUI Backend Capabilities",
+		description: "Read the backend capability and version envelope as JSON.",
+		mimeType: JSON_MIME_TYPE
+	}, (uri) => jsonResource(uri, runtime.getCapabilities()));
+	server.registerResource("openfairygui_backend_session", new ResourceTemplate("openfairygui://backend/session/{sessionId}", { list: void 0 }), {
+		title: "OpenFairyGUI Backend Session Snapshot",
+		description: "Read a backend session envelope by backend-local session id.",
+		mimeType: JSON_MIME_TYPE
+	}, (uri, variables) => jsonResource(uri, runtime.getSession({ sessionId: firstVariable(variables.sessionId) })));
+	server.registerResource("openfairygui_backend_cache", new ResourceTemplate("openfairygui://backend/cache/{sessionId}", { list: void 0 }), {
+		title: "OpenFairyGUI Backend Cache Snapshot",
+		description: "Read a derived backend cache envelope by backend-local session id.",
+		mimeType: JSON_MIME_TYPE
+	}, (uri, variables) => jsonResource(uri, runtime.getCacheSnapshot({ sessionId: firstVariable(variables.sessionId) })));
+	server.registerResource("openfairygui_backend_job", new ResourceTemplate("openfairygui://backend/job/{sessionId}/{jobId}", { list: void 0 }), {
+		title: "OpenFairyGUI Backend Job Snapshot",
+		description: "Read a backend runtime job envelope by session id and job id.",
+		mimeType: JSON_MIME_TYPE
+	}, (uri, variables) => jsonResource(uri, runtime.getJob({
+		sessionId: firstVariable(variables.sessionId),
+		jobId: firstVariable(variables.jobId)
+	})));
+}
+//#endregion
+//#region src/tool-handler.ts
+function jsonResult(payload, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		}],
+		structuredContent: { backendResult: payload },
+		isError
+	};
+}
+function isBackendFailure(value) {
+	return typeof value === "object" && value !== null && "ok" in value && value.ok === false;
+}
+async function callOpenFairyGuiBackendTool(runtime, name, input) {
+	let result;
+	switch (name) {
+		case "openfairygui_backend_get_capabilities":
+			result = runtime.getCapabilities();
+			break;
+		case "openfairygui_backend_open_session":
+			result = await runtime.openSession({ projectPath: String(input.projectPath) });
+			break;
+		case "openfairygui_backend_get_session":
+			result = runtime.getSession({ sessionId: String(input.sessionId) });
+			break;
+		case "openfairygui_backend_apply_transaction":
+			result = await runtime.applyTransaction({
+				sessionId: String(input.sessionId),
+				expectedRevision: Number(input.expectedRevision),
+				operations: input.operations
+			});
+			break;
+		case "openfairygui_backend_save_session":
+			result = await runtime.saveSession({
+				sessionId: String(input.sessionId),
+				expectedRevision: input.expectedRevision === void 0 ? void 0 : Number(input.expectedRevision),
+				targetPath: input.targetPath === void 0 ? void 0 : String(input.targetPath)
+			});
+			break;
+		case "openfairygui_backend_close_session":
+			result = await runtime.closeSession({ sessionId: String(input.sessionId) });
+			break;
+		case "openfairygui_backend_get_events":
+			result = runtime.getEvents({
+				sessionId: String(input.sessionId),
+				after: input.after === void 0 ? void 0 : String(input.after),
+				limit: input.limit === void 0 ? void 0 : Number(input.limit)
+			});
+			break;
+		case "openfairygui_backend_get_job":
+			result = runtime.getJob({
+				sessionId: String(input.sessionId),
+				jobId: String(input.jobId)
+			});
+			break;
+		case "openfairygui_backend_list_jobs":
+			result = runtime.listJobs({
+				sessionId: String(input.sessionId),
+				status: input.status,
+				kind: input.kind,
+				limit: input.limit === void 0 ? void 0 : Number(input.limit)
+			});
+			break;
+		case "openfairygui_backend_cancel_job":
+			result = runtime.cancelJob({
+				sessionId: String(input.sessionId),
+				jobId: String(input.jobId)
+			});
+			break;
+		case "openfairygui_backend_get_cache_snapshot":
+			result = runtime.getCacheSnapshot({ sessionId: String(input.sessionId) });
+			break;
+		case "openfairygui_backend_refresh_cache":
+			result = runtime.refreshCache({
+				sessionId: String(input.sessionId),
+				reason: input.reason
+			});
+			break;
+		default: throw new Error(`Unknown OpenFairyGUI backend MCP tool: ${name}`);
+	}
+	return jsonResult(result, isBackendFailure(result));
+}
+//#endregion
+//#region src/tool-definitions.ts
+const OPENFAIRYGUI_BACKEND_TOOL_PREFIX = "openfairygui_backend_";
+const OPENFAIRYGUI_BACKEND_TOOL_NAMES = [
+	"openfairygui_backend_get_capabilities",
+	"openfairygui_backend_open_session",
+	"openfairygui_backend_get_session",
+	"openfairygui_backend_apply_transaction",
+	"openfairygui_backend_save_session",
+	"openfairygui_backend_close_session",
+	"openfairygui_backend_get_events",
+	"openfairygui_backend_get_job",
+	"openfairygui_backend_list_jobs",
+	"openfairygui_backend_cancel_job",
+	"openfairygui_backend_get_cache_snapshot",
+	"openfairygui_backend_refresh_cache"
+];
+const sessionId = z.string().min(1);
+const jobId = z.string().min(1);
+const expectedRevision = z.number().int().nonnegative();
+const limit = z.number().int().nonnegative().optional();
+const OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA = z.object({ backendResult: z.object({
+	ok: z.boolean(),
+	data: z.unknown().optional(),
+	error: z.unknown().optional(),
+	meta: z.unknown().optional()
+}).passthrough() });
+const OPENFAIRYGUI_BACKEND_TOOL_DEFINITIONS = [
+	{
+		name: "openfairygui_backend_get_capabilities",
+		backendMethod: "getCapabilities",
+		title: "Get Backend Capabilities",
+		description: "Return the OpenFairyGUI backend capability, version, and service-plane snapshot.",
+		inputSchema: z.object({}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_open_session",
+		backendMethod: "openSession",
+		title: "Open Backend Session",
+		description: "Open a FairyGUI project through BackendRuntime and acquire its backend-local session lock.",
+		inputSchema: z.object({ projectPath: z.string().min(1) }),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_get_session",
+		backendMethod: "getSession",
+		title: "Get Backend Session",
+		description: "Return a backend session snapshot by session id.",
+		inputSchema: z.object({ sessionId }),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_apply_transaction",
+		backendMethod: "applyTransaction",
+		title: "Apply UAM Transaction",
+		description: "Apply a backend revision-checked UAM operation batch without redefining selector or operation grammar.",
+		inputSchema: z.object({
+			sessionId,
+			expectedRevision,
+			operations: z.array(z.unknown())
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_save_session",
+		backendMethod: "saveSession",
+		title: "Save Backend Session",
+		description: "Write the current backend session back through the backend coordinated non-atomic save path.",
+		inputSchema: z.object({
+			sessionId,
+			expectedRevision: expectedRevision.optional(),
+			targetPath: z.string().min(1).optional()
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_close_session",
+		backendMethod: "closeSession",
+		title: "Close Backend Session",
+		description: "Close a backend session and release its backend-local advisory lock.",
+		inputSchema: z.object({ sessionId }),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_get_events",
+		backendMethod: "getEvents",
+		title: "Get Runtime Events",
+		description: "Poll backend runtime events for a session using the backend P2 event cursor contract.",
+		inputSchema: z.object({
+			sessionId,
+			after: z.string().optional(),
+			limit
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_get_job",
+		backendMethod: "getJob",
+		title: "Get Runtime Job",
+		description: "Return a backend runtime job snapshot by session and backend-local job id.",
+		inputSchema: z.object({
+			sessionId,
+			jobId
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_list_jobs",
+		backendMethod: "listJobs",
+		title: "List Runtime Jobs",
+		description: "List backend runtime jobs for a session with backend P2 status/kind filters.",
+		inputSchema: z.object({
+			sessionId,
+			status: z.enum([
+				"queued",
+				"running",
+				"completed",
+				"failed",
+				"cancelled",
+				"active",
+				"terminal"
+			]).optional(),
+			kind: z.literal("cache.refresh").optional(),
+			limit
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_cancel_job",
+		backendMethod: "cancelJob",
+		title: "Cancel Runtime Job",
+		description: "Request cooperative cancellation for a backend runtime job.",
+		inputSchema: z.object({
+			sessionId,
+			jobId
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_get_cache_snapshot",
+		backendMethod: "getCacheSnapshot",
+		title: "Get Cache Snapshot",
+		description: "Return the backend P2 derived read-only cache snapshot for a session.",
+		inputSchema: z.object({ sessionId }),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	},
+	{
+		name: "openfairygui_backend_refresh_cache",
+		backendMethod: "refreshCache",
+		title: "Refresh Cache",
+		description: "Create a backend P2 cache.refresh job for the session cache snapshot.",
+		inputSchema: z.object({
+			sessionId,
+			reason: z.enum([
+				"manual",
+				"session_open",
+				"after_save"
+			]).optional()
+		}),
+		outputSchema: OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: false,
+			openWorldHint: false
+		}
+	}
+];
+//#endregion
+//#region src/server.ts
+const PACKAGE_VERSION = process.env.npm_package_version ?? "0.2.0-alpha.0";
+function createOpenFairyGuiMcpServer(options = {}) {
+	const runtime = options.runtime ?? new BackendRuntime();
+	const server = new McpServer({
+		name: options.name ?? "openfairygui-mcp",
+		version: options.version ?? PACKAGE_VERSION
+	});
+	for (const definition of OPENFAIRYGUI_BACKEND_TOOL_DEFINITIONS) server.registerTool(definition.name, {
+		title: definition.title,
+		description: definition.description,
+		inputSchema: definition.inputSchema,
+		outputSchema: definition.outputSchema,
+		annotations: definition.annotations,
+		_meta: {
+			"openfairygui/backendMethod": definition.backendMethod,
+			"openfairygui/adapter": "thin-backend-p2"
+		}
+	}, async (args) => callOpenFairyGuiBackendTool(runtime, definition.name, args));
+	registerOpenFairyGuiBackendResources(server, runtime);
+	registerOpenFairyGuiBackendPrompts(server);
+	return server;
+}
+//#endregion
+//#region src/stdio.ts
+async function connectOpenFairyGuiMcpStdio() {
+	await createOpenFairyGuiMcpServer().connect(new StdioServerTransport());
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) connectOpenFairyGuiMcpStdio().catch((error) => {
+	console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export { OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA as a, OPENFAIRYGUI_BACKEND_CAPABILITIES_RESOURCE_URI as c, OPENFAIRYGUI_BACKEND_PROMPT_NAMES as d, OPENFAIRYGUI_BACKEND_TOOL_NAMES as i, OPENFAIRYGUI_BACKEND_RESOURCE_TEMPLATES as l, createOpenFairyGuiMcpServer as n, OPENFAIRYGUI_BACKEND_TOOL_PREFIX as o, OPENFAIRYGUI_BACKEND_TOOL_DEFINITIONS as r, callOpenFairyGuiBackendTool as s, connectOpenFairyGuiMcpStdio as t, OPENFAIRYGUI_BACKEND_PROMPT_DEFINITIONS as u };

package/dist/stdio.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_stdio = require("./stdio-BDHxauin.cjs");
+exports.connectOpenFairyGuiMcpStdio = require_stdio.connectOpenFairyGuiMcpStdio;

package/dist/stdio.d.cts

@@ -0,0 +1,4 @@
+//#region src/stdio.d.ts
+declare function connectOpenFairyGuiMcpStdio(): Promise<void>;
+//#endregion
+export { connectOpenFairyGuiMcpStdio };

package/dist/stdio.d.mts

@@ -0,0 +1,4 @@
+//#region src/stdio.d.ts
+declare function connectOpenFairyGuiMcpStdio(): Promise<void>;
+//#endregion
+export { connectOpenFairyGuiMcpStdio };

package/dist/stdio.mjs

@@ -0,0 +1,2 @@
+import { t as connectOpenFairyGuiMcpStdio } from "./stdio-ByGWerIG.mjs";
+export { connectOpenFairyGuiMcpStdio };

package/package.json

@@ -0,0 +1,85 @@
+{
+	"name": "@openfairygui/mcp",
+	"version": "0.2.0-alpha.0",
+	"description": "FairyGUI Headless Authoring SDK - MCP server adapter for the backend runtime.",
+	"author": "OpenFairyGUI Contributors",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/OpenFairyGUI/OpenFairyGUI.git",
+		"directory": "packages/mcp"
+	},
+	"homepage": "https://github.com/OpenFairyGUI/OpenFairyGUI#readme",
+	"bugs": {
+		"url": "https://github.com/OpenFairyGUI/OpenFairyGUI/issues"
+	},
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"exports": {
+		".": {
+			"require": {
+				"types": "./dist/index.d.cts",
+				"default": "./dist/index.cjs"
+			},
+			"default": {
+				"types": "./dist/index.d.mts",
+				"default": "./dist/index.mjs"
+			}
+		},
+		"./stdio": {
+			"require": {
+				"types": "./dist/stdio.d.cts",
+				"default": "./dist/stdio.cjs"
+			},
+			"default": {
+				"types": "./dist/stdio.d.mts",
+				"default": "./dist/stdio.mjs"
+			}
+		}
+	},
+	"bin": {
+		"ofgui-mcp": "bin/ofgui-mcp.cjs"
+	},
+	"scripts": {
+		"build": "tsdown src/index.ts src/stdio.ts --format esm,cjs --platform node --external node:fs --external node:path --external node:fs/promises --env.PACKAGE_VERSION=$npm_package_version",
+		"build:watch": "tsdown src/index.ts src/stdio.ts --watch --format esm,cjs --platform node --env.PACKAGE_VERSION=$npm_package_version",
+		"test": "ava test/**/*.test.ts --no-worker-threads"
+	},
+	"files": [
+		"dist/",
+		"bin/",
+		"src/"
+	],
+	"keywords": [
+		"fairygui",
+		"mcp",
+		"model-context-protocol",
+		"backend",
+		"authoring"
+	],
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.29.0",
+		"@openfairygui/backend": "workspace:*",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"@openfairygui/core": "workspace:*",
+		"ava": "^7.0.0",
+		"tsx": "^4.0.0"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module"
+		},
+		"nodeArguments": [
+			"--import",
+			"tsx/esm"
+		],
+		"files": [
+			"test/**/*.test.ts"
+		]
+	}
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export {
+	createOpenFairyGuiMcpServer,
+	type CreateOpenFairyGuiMcpServerOptions,
+} from './server.js';
+export {
+	connectOpenFairyGuiMcpStdio,
+} from './stdio.js';
+export {
+	callOpenFairyGuiBackendTool,
+} from './tool-handler.js';
+export {
+	OPENFAIRYGUI_BACKEND_PROMPT_DEFINITIONS,
+	OPENFAIRYGUI_BACKEND_PROMPT_NAMES,
+	type OpenFairyGuiBackendPromptName,
+} from './prompt-definitions.js';
+export {
+	OPENFAIRYGUI_BACKEND_CAPABILITIES_RESOURCE_URI,
+	OPENFAIRYGUI_BACKEND_RESOURCE_TEMPLATES,
+} from './resource-definitions.js';
+export {
+	OPENFAIRYGUI_BACKEND_TOOL_DEFINITIONS,
+	OPENFAIRYGUI_BACKEND_TOOL_NAMES,
+	OPENFAIRYGUI_BACKEND_TOOL_OUTPUT_SCHEMA,
+	OPENFAIRYGUI_BACKEND_TOOL_PREFIX,
+	type BackendMethodName,
+	type OpenFairyGuiBackendToolDefinition,
+	type OpenFairyGuiBackendToolName,
+} from './tool-definitions.js';