touchdesigner-mcp-server 1.4.8 → 1.4.9

package/dist/features/tools/handlers/tdTools.js

@@ -1,22 +1,10 @@
 import { z } from "zod";
-import { REFERENCE_COMMENT, TOOL_NAMES } from "../../../core/constants.js";
+import { TOOL_NAMES } from "../../../core/constants.js";
 import { handleToolError } from "../../../core/errorHandling.js";
-import { CreateNodeBody, DeleteNodeQueryParams, ExecNodeMethodBody, ExecPythonScriptBody, GetModuleHelpQueryParams, GetNodeDetailQueryParams, GetNodeErrorsQueryParams, GetNodesQueryParams, GetTdPythonClassDetailsParams, UpdateNodeBody, } from "../../../gen/mcp/touchDesignerAPI.zod.js";
-import { getTouchDesignerToolMetadata } from "../metadata/touchDesignerToolMetadata.js";
-import { formatClassDetails, formatClassList, formatCreateNodeResult, formatDeleteNodeResult, formatExecNodeMethodResult, formatModuleHelp, formatNodeDetails, formatNodeErrors, formatNodeList, formatScriptResult, formatTdInfo, formatToolMetadata, formatUpdateNodeResult, } from "../presenter/index.js";
-import { detailOnlyFormattingSchema, formattingOptionsSchema, } from "../types.js";
-const execPythonScriptToolSchema = ExecPythonScriptBody.extend(detailOnlyFormattingSchema.shape);
-const tdInfoToolSchema = detailOnlyFormattingSchema;
-const getNodesToolSchema = GetNodesQueryParams.extend(formattingOptionsSchema.shape);
-const getNodeDetailToolSchema = GetNodeDetailQueryParams.extend(formattingOptionsSchema.shape);
-const getNodeErrorsToolSchema = GetNodeErrorsQueryParams.extend(formattingOptionsSchema.shape);
-const createNodeToolSchema = CreateNodeBody.extend(detailOnlyFormattingSchema.shape);
-const updateNodeToolSchema = UpdateNodeBody.extend(detailOnlyFormattingSchema.shape);
-const deleteNodeToolSchema = DeleteNodeQueryParams.extend(detailOnlyFormattingSchema.shape);
-const classListToolSchema = formattingOptionsSchema;
-const classDetailToolSchema = GetTdPythonClassDetailsParams.extend(formattingOptionsSchema.shape);
-const moduleHelpToolSchema = GetModuleHelpQueryParams.extend(detailOnlyFormattingSchema.shape);
-const execNodeMethodToolSchema = ExecNodeMethodBody.extend(detailOnlyFormattingSchema.shape);
+import { buildToolMetadata, } from "../metadata/touchDesignerToolMetadata.js";
+import { formatToolMetadata } from "../presenter/index.js";
+import { TOOL_DEFINITIONS } from "../toolDefinitions.js";
+import { detailOnlyFormattingSchema } from "../types.js";
 const describeToolsSchema = detailOnlyFormattingSchema.extend({
     filter: z
         .string()
@@ -25,7 +13,21 @@ const describeToolsSchema = detailOnlyFormattingSchema.extend({
         .optional(),
 });
 export function registerTdTools(server, logger, tdClient) {
-    const toolMetadataEntries = getTouchDesignerToolMetadata();
+    // Register every TouchDesigner operation from the single source of truth.
+    for (const definition of TOOL_DEFINITIONS) {
+        server.tool(definition.name, definition.description, definition.schema.strict().shape, async (params = {}) => {
+            try {
+                const text = await definition.run({ logger, params, tdClient });
+                return createToolResult(tdClient, text);
+            }
+            catch (error) {
+                return handleToolError(error, logger, definition.name, definition.errorComment);
+            }
+        });
+    }
+    // `describe_td_tools` is the meta tool: it documents the tools above rather
+    // than calling TouchDesigner, so it is registered on its own.
+    const toolMetadataEntries = buildToolMetadata(TOOL_DEFINITIONS);
     server.tool(TOOL_NAMES.DESCRIBE_TD_TOOLS, "Generate a filesystem-oriented manifest of available TouchDesigner tools", describeToolsSchema.strict().shape, async (params = {}) => {
         try {
             const { detailLevel, responseFormat, filter } = params;
@@ -38,12 +40,7 @@ export function registerTdTools(server, logger, tdClient) {
                     ? `No TouchDesigner tools matched filter "${filter}".`
                     : "No TouchDesigner tools are registered.";
                 return {
-                    content: [
-                        {
-                            text: message,
-                            type: "text",
-                        },
-                    ],
+                    content: [{ text: message, type: "text" }],
                 };
             }
             const formattedText = formatToolMetadata(filteredEntries, {
@@ -52,247 +49,17 @@ export function registerTdTools(server, logger, tdClient) {
                 responseFormat,
             });
             return {
-                content: [
-                    {
-                        text: formattedText,
-                        type: "text",
-                    },
-                ],
+                content: [{ text: formattedText, type: "text" }],
             };
         }
         catch (error) {
             return handleToolError(error, logger, TOOL_NAMES.DESCRIBE_TD_TOOLS);
         }
     });
-    server.tool(TOOL_NAMES.GET_TD_INFO, "Get server information from TouchDesigner", tdInfoToolSchema.strict().shape, async (params = {}) => {
-        try {
-            const { detailLevel, responseFormat } = params;
-            const result = await tdClient.getTdInfo();
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatTdInfo(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_INFO);
-        }
-    });
-    server.tool(TOOL_NAMES.EXECUTE_PYTHON_SCRIPT, "Execute a Python script in TouchDesigner (detailLevel=minimal|summary|detailed, responseFormat=json|yaml|markdown)", execPythonScriptToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, responseFormat, ...scriptParams } = params;
-            logger.sendLog({
-                data: `Executing script: ${scriptParams.script}`,
-                level: "debug",
-            });
-            const result = await tdClient.execPythonScript(scriptParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            // Use formatter for token-optimized response
-            const formattedText = formatScriptResult(result, scriptParams.script, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.EXECUTE_PYTHON_SCRIPT);
-        }
-    });
-    server.tool(TOOL_NAMES.CREATE_TD_NODE, "Create a new node in TouchDesigner", createNodeToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, responseFormat, ...createParams } = params;
-            const result = await tdClient.createNode(createParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatCreateNodeResult(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.CREATE_TD_NODE, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.DELETE_TD_NODE, "Delete an existing node in TouchDesigner", deleteNodeToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, responseFormat, ...deleteParams } = params;
-            const result = await tdClient.deleteNode(deleteParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatDeleteNodeResult(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.DELETE_TD_NODE, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_NODES, "List nodes under a path with token-optimized output (detailLevel+limit supported)", getNodesToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, limit, responseFormat, ...queryParams } = params;
-            const result = await tdClient.getNodes(queryParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            // Use formatter for token-optimized response
-            const fallbackMode = queryParams.includeProperties
-                ? "detailed"
-                : "summary";
-            const formattedText = formatNodeList(result.data, {
-                detailLevel: detailLevel ?? fallbackMode,
-                limit,
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_NODES, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_NODE_PARAMETERS, "Get node parameters with concise/detailed formatting (detailLevel+limit supported)", getNodeDetailToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, limit, responseFormat, ...queryParams } = params;
-            const result = await tdClient.getNodeDetail(queryParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            // Use formatter for token-optimized response
-            const formattedText = formatNodeDetails(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                limit,
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_NODE_PARAMETERS, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_NODE_ERRORS, "Check node and descendant errors reported by TouchDesigner", getNodeErrorsToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, limit, responseFormat, ...queryParams } = params;
-            const result = await tdClient.getNodeErrors(queryParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatNodeErrors(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                limit,
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_NODE_ERRORS, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.UPDATE_TD_NODE_PARAMETERS, "Update parameters of a specific node in TouchDesigner", updateNodeToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, responseFormat, ...updateParams } = params;
-            const result = await tdClient.updateNode(updateParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatUpdateNodeResult(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.UPDATE_TD_NODE_PARAMETERS, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.EXECUTE_NODE_METHOD, "Execute a method on a specific node in TouchDesigner", execNodeMethodToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, responseFormat, ...execParams } = params;
-            const { nodePath, method, args, kwargs } = execParams;
-            const result = await tdClient.execNodeMethod(execParams);
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatExecNodeMethodResult(result.data, { args, kwargs, method, nodePath }, { detailLevel: detailLevel ?? "summary", responseFormat });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            logger.sendLog({
-                data: error,
-                level: "error",
-            });
-            return handleToolError(error, logger, TOOL_NAMES.EXECUTE_NODE_METHOD, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_CLASSES, "List TouchDesigner Python classes/modules (detailLevel+limit supported)", classListToolSchema.strict().shape, async (params = {}) => {
-        try {
-            const result = await tdClient.getClasses();
-            if (!result.success) {
-                throw result.error;
-            }
-            // Use formatter for token-optimized response
-            const formattedText = formatClassList(result.data, {
-                detailLevel: params.detailLevel ?? "summary",
-                limit: params.limit ?? 50,
-                responseFormat: params.responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_CLASSES, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_CLASS_DETAILS, "Get information about a TouchDesigner class/module (detailLevel+limit supported)", classDetailToolSchema.strict().shape, async (params) => {
-        try {
-            const { className, detailLevel, limit, responseFormat } = params;
-            const result = await tdClient.getClassDetails(className);
-            if (!result.success) {
-                throw result.error;
-            }
-            // Use formatter for token-optimized response
-            const formattedText = formatClassDetails(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                limit: limit ?? 30,
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_CLASS_DETAILS, REFERENCE_COMMENT);
-        }
-    });
-    server.tool(TOOL_NAMES.GET_TD_MODULE_HELP, "Retrieve Python help() text for a TouchDesigner module or class", moduleHelpToolSchema.strict().shape, async (params) => {
-        try {
-            const { detailLevel, moduleName, responseFormat } = params;
-            const result = await tdClient.getModuleHelp({ moduleName });
-            if (!result.success) {
-                throw result.error;
-            }
-            const formattedText = formatModuleHelp(result.data, {
-                detailLevel: detailLevel ?? "summary",
-                responseFormat,
-            });
-            return createToolResult(tdClient, formattedText);
-        }
-        catch (error) {
-            return handleToolError(error, logger, TOOL_NAMES.GET_TD_MODULE_HELP);
-        }
-    });
 }
 const createToolResult = (tdClient, text) => {
     const content = [
-        {
-            text,
-            type: "text",
-        },
+        { text, type: "text" },
     ];
     const additionalContents = tdClient.getAdditionalToolResultContents();
     if (additionalContents) {