touchdesigner-mcp-server 1.4.8 → 1.4.10

package/dist/api/customInstance.d.ts

@@ -0,0 +1,5 @@
+import { type AxiosError, type AxiosRequestConfig } from "axios";
+export declare const AXIOS_INSTANCE: import("axios").AxiosInstance;
+export declare const customInstance: <T>(config: AxiosRequestConfig, options?: AxiosRequestConfig) => Promise<T>;
+export type ErrorType<E> = AxiosError<E>;
+export type BodyType<BodyData> = BodyData;

package/dist/cli.d.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import type { TransportConfig } from "./transport/config.js";
+/**
+ * Parse command line arguments for TouchDesigner connection
+ */
+export declare function parseArgs(args?: string[]): {
+    host: string;
+    port: number;
+};
+/**
+ * Parse transport configuration from command line arguments
+ *
+ * Detects if HTTP mode is requested via --mcp-http-port flag.
+ * If not specified, defaults to stdio mode.
+ *
+ * @param args - Command line arguments (defaults to process.argv.slice(2))
+ * @returns Transport configuration (stdio or streamable-http)
+ *
+ * @example
+ * ```bash
+ * # Stdio mode (default)
+ * touchdesigner-mcp-server --host=http://localhost --port=9981
+ *
+ * # HTTP mode
+ * touchdesigner-mcp-server --mcp-http-port=6280 --mcp-http-host=127.0.0.1
+ * ```
+ */
+export declare function parseTransportConfig(args?: string[]): TransportConfig;
+/**
+ * Start TouchDesigner MCP server
+ *
+ * Supports both stdio and HTTP transport modes based on command line arguments.
+ *
+ * @param params - Server startup parameters
+ * @param params.argv - Command line arguments
+ * @param params.nodeEnv - Node environment
+ *
+ * @example
+ * ```bash
+ * # Stdio mode (default)
+ * touchdesigner-mcp-server --host=http://localhost --port=9981
+ *
+ * # HTTP mode
+ * touchdesigner-mcp-server --mcp-http-port=6280 --host=http://localhost --port=9981
+ * ```
+ */
+export declare function startServer(params?: {
+    nodeEnv?: string;
+    argv?: string[];
+}): Promise<void>;

package/dist/core/compatibility.d.ts

@@ -0,0 +1,102 @@
+export declare const COMPATIBILITY_POLICY_TYPES: {
+    readonly BELOW_MIN_VERSION: "belowMinVersion";
+    readonly COMPATIBLE: "compatible";
+    readonly MAJOR_MISMATCH: "majorMismatch";
+    readonly NEWER_MINOR: "newerMinor";
+    readonly NO_VERSION: "noVersion";
+    readonly OLDER_MINOR: "olderMinor";
+    readonly PATCH_DIFF: "patchDiff";
+};
+export declare const COMPATIBILITY_POLICY_ERROR_LEVELS: {
+    readonly ALLOW: "info";
+    readonly ERROR: "error";
+    readonly WARNING: "warning";
+};
+export type CompatibilityPolicyType = (typeof COMPATIBILITY_POLICY_TYPES)[keyof typeof COMPATIBILITY_POLICY_TYPES];
+export type CompatibilityPolicyErrorLevel = (typeof COMPATIBILITY_POLICY_ERROR_LEVELS)[keyof typeof COMPATIBILITY_POLICY_ERROR_LEVELS];
+export declare const getCompatibilityPolicyType: (params: {
+    mcpVersion: string;
+    apiVersion: string;
+}) => CompatibilityPolicyType;
+export declare const getCompatibilityPolicy: (type: CompatibilityPolicyType) => {
+    readonly compatible: false;
+    readonly level: "error";
+    readonly message: typeof generateNoVersionMessage;
+} | {
+    readonly compatible: false;
+    readonly level: "error";
+    readonly message: typeof generateMinVersionMessage;
+} | {
+    readonly compatible: false;
+    readonly level: "error";
+    readonly message: typeof generateMajorMismatchMessage;
+} | {
+    readonly compatible: true;
+    readonly level: "warning";
+    readonly message: typeof generateNewerMinorMessage;
+} | {
+    readonly compatible: true;
+    readonly level: "warning";
+    readonly message: typeof generateOlderMinorMessage;
+} | {
+    readonly compatible: true;
+    readonly level: "info";
+    readonly message: typeof generatePatchDiffMessage;
+} | {
+    readonly compatible: true;
+    readonly level: "info";
+    readonly message: typeof generateFullyCompatibleMessage;
+};
+/**
+ * Generate error message for unknown version information
+ */
+export declare function generateNoVersionMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;
+/**
+ * Generate error message for MAJOR version mismatch
+ */
+export declare function generateMajorMismatchMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;
+/**
+ * Generate error message when API version is below minimum compatible version
+ */
+export declare function generateMinVersionMessage(args: {
+    apiVersion: string;
+    minRequired: string;
+}): string;
+/**
+ * Generate warning message when MCP server has newer MINOR version
+ */
+export declare function generateNewerMinorMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;
+/**
+ * Generate warning message when API server has newer MINOR version
+ */
+export declare function generateOlderMinorMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;
+/**
+ * Generate warning message when PATCH versions differ
+ */
+export declare function generatePatchDiffMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;
+/**
+ * Generate info message when versions are fully compatible
+ *
+ * @param mcpVersion MCP server version
+ * @param apiVersion TouchDesigner API server version
+ * @returns Info message
+ */
+export declare function generateFullyCompatibleMessage(args: {
+    apiVersion: string;
+    mcpVersion: string;
+}): string;

package/dist/core/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Reference URLs for TouchDesigner Python documentation
+ */
+export declare const TD_PYTHON_CLASS_REFERENCE_BASE_URL = "https://docs.derivative.ca";
+export declare const TD_PYTHON_CLASS_REFERENCE_INDEX_URL = "https://docs.derivative.ca/Python_Classes_and_Modules";
+/**
+ * Reference Tool Names for TouchDesigner MCP
+ */
+export declare const TOOL_NAMES: {
+    readonly CREATE_TD_NODE: "create_td_node";
+    readonly DELETE_TD_NODE: "delete_td_node";
+    readonly DESCRIBE_TD_TOOLS: "describe_td_tools";
+    readonly EXECUTE_NODE_METHOD: "exec_node_method";
+    readonly EXECUTE_PYTHON_SCRIPT: "execute_python_script";
+    readonly GET_TD_CLASS_DETAILS: "get_td_class_details";
+    readonly GET_TD_CLASSES: "get_td_classes";
+    readonly GET_TD_INFO: "get_td_info";
+    readonly GET_TD_MODULE_HELP: "get_td_module_help";
+    readonly GET_TD_NODE_ERRORS: "get_td_node_errors";
+    readonly GET_TD_NODE_PARAMETERS: "get_td_node_parameters";
+    readonly GET_TD_NODES: "get_td_nodes";
+    readonly UPDATE_TD_NODE_PARAMETERS: "update_td_node_parameters";
+};
+export declare const REFERENCE_COMMENT = "Check reference resources: https://docs.derivative.ca/Python_Classes_and_Modules";
+export declare const PROMPT_NAMES: {
+    readonly CHECK_NODE_ERRORS: "Check node errors";
+    readonly NODE_CONNECTION: "Node connection";
+    readonly SEARCH_NODE: "Search node";
+};

package/dist/core/errorHandling.d.ts

@@ -0,0 +1,18 @@
+import type { ToolNames } from "../features/tools/index.js";
+import type { ILogger } from "./logger.js";
+/**
+ * Standard API error response structure compatible with MCP SDK
+ */
+interface ErrorResponse {
+    [key: string]: unknown;
+    isError: true;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}
+/**
+ * Handles API errors consistently across the application
+ */
+export declare function handleToolError(error: unknown, logger: ILogger, toolName: ToolNames, referenceComment?: string): ErrorResponse;
+export {};

package/dist/core/logger.d.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Logger interface definition
+ */
+export interface ILogger {
+    sendLog(args: LoggingMessageNotification["params"]): void;
+}
+/**
+ * MCP compatible logger implementation
+ * Handles "Not connected" errors gracefully
+ */
+export declare class McpLogger implements ILogger {
+    private server;
+    constructor(server: McpServer);
+    sendLog(args: LoggingMessageNotification["params"]): void;
+}
+/**
+ * Console Logger implementation for standalone use (e.g., HTTP mode setup)
+ * Outputs to stderr to avoid interfering with stdio transport
+ */
+export declare class ConsoleLogger implements ILogger {
+    sendLog(args: LoggingMessageNotification["params"]): void;
+}

package/dist/core/result.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Result type pattern for handling operation results
+ * Success case contains data, failure case contains error
+ */
+export type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+/**
+ * Creates a success result with the provided data
+ */
+export declare function createSuccessResult<T>(data: T): {
+    success: true;
+    data: T;
+};
+/**
+ * Creates an error result with the provided error
+ */
+export declare function createErrorResult<E = Error>(error: E): {
+    success: false;
+    error: E;
+};

package/dist/core/version.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Current MCP server version
+ */
+export declare const getMcpServerVersion: () => string;
+export declare const MCP_SERVER_VERSION: string;
+/**
+ * Minimum compatible TouchDesigner API Server version required by the MCP server
+ *
+ * Loaded from package.json's mcpCompatibility.minApiVersion field.
+ * Falls back to the current package version if undefined.
+ *
+ * API Server must be at or above this version.
+ * - MAJOR mismatch: Error
+ * - MINOR/PATCH differences: Warning or allow
+ *
+ * Update when:
+ * - Introducing breaking API changes
+ * - Making incompatible changes to OpenAPI schema
+ */
+export declare const getMinCompatibleApiVersion: () => string;
+export declare const MIN_COMPATIBLE_API_VERSION: string;

package/dist/features/prompts/handlers/td_prompts.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ILogger } from "../../../core/logger.js";
+/**
+ * Register prompt handlers with MCP server
+ */
+export declare function registerTdPrompts(server: McpServer, logger: ILogger): void;

package/dist/features/prompts/index.d.ts

@@ -0,0 +1 @@
+export * from "./register.js";

package/dist/features/prompts/register.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ILogger } from "../../core/logger.js";
+/**
+ * Register prompt handlers with MCP server
+ */
+export declare function registerPrompts(server: McpServer, logger: ILogger): void;

package/dist/features/tools/handlers/tdTools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ILogger } from "../../../core/logger.js";
+import type { TouchDesignerClient } from "../../../tdClient/touchDesignerClient.js";
+export declare function registerTdTools(server: McpServer, logger: ILogger, tdClient: TouchDesignerClient): void;

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) {

package/dist/features/tools/index.d.ts

@@ -0,0 +1,3 @@
+import type { TOOL_NAMES } from "../../core/constants.js";
+export * from "./register.js";
+export type ToolNames = (typeof TOOL_NAMES)[keyof typeof TOOL_NAMES];

package/dist/features/tools/metadata/touchDesignerToolMetadata.d.ts

@@ -0,0 +1,29 @@
+import type { z } from "zod";
+import type { ToolNames } from "../index.js";
+import { type ToolCategory, type ToolDefinition } from "../toolDefinitions.js";
+export type { ToolCategory };
+export interface ToolParameterMetadata {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+}
+export interface ToolMetadata {
+    tool: ToolNames;
+    modulePath: string;
+    functionName: string;
+    description: string;
+    category: ToolCategory;
+    parameters: ToolParameterMetadata[];
+    returns: string;
+    example: string;
+    notes?: string;
+}
+/**
+ * Builds the `describe_td_tools` manifest from the tool table. Parameter
+ * metadata is introspected from each tool's Zod schema, so it always reflects
+ * the schema that is actually registered (sourced from the OpenAPI spec).
+ */
+export declare function buildToolMetadata(definitions?: readonly ToolDefinition[]): ToolMetadata[];
+/** Introspects a Zod object schema into flat parameter metadata. */
+export declare function deriveParameters(schema: z.ZodObject<z.ZodRawShape>): ToolParameterMetadata[];