send_code_to_revit

Instructions

Implementation Reference

• src/tools/send_code_to_revit.ts:22-57 (handler)

  The asynchronous handler function that implements the core logic of the 'send_code_to_revit' tool. It prepares parameters from the input arguments, uses withRevitConnection to send the command to the Revit client, and formats the response or error as MCP content.

  async (args, extra) => {
    const params = {
      code: args.code,
      parameters: args.parameters || [],
    };
  
    try {
      const response = await withRevitConnection(async (revitClient) => {
        return await revitClient.sendCommand("send_code_to_revit", params);
      });
  
      return {
        content: [
          {
            type: "text",
            text: `Code execution successful!\nResult: ${JSON.stringify(
              response,
              null,
              2
            )}`,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Code execution failed: ${
              error instanceof Error ? error.message : String(error)
            }`,
          },
        ],
      };
    }
  }

• src/tools/send_code_to_revit.ts:9-21 (schema)

  Zod schema defining the input parameters for the tool: 'code' (required string) and 'parameters' (optional array). Used in server.tool() registration.

  {
    code: z
      .string()
      .describe(
        "The C# code to execute in Revit. This code will be inserted into the Execute method of a template with access to Document and parameters."
      ),
    parameters: z
      .array(z.any())
      .optional()
      .describe(
        "Optional execution parameters that will be passed to your code"
      ),
  },

• src/tools/send_code_to_revit.ts:5-59 (registration)

  The registration function exported from the tool file. It calls server.tool() to register the 'send_code_to_revit' MCP tool with its name, description, input schema, and handler. This function is dynamically invoked by src/tools/register.ts.

  export function registerSendCodeToRevitTool(server: McpServer) {
    server.tool(
      "send_code_to_revit",
      "Send C# code to Revit for execution. The code will be inserted into a template with access to the Revit Document and parameters. Your code should be written to work within the Execute method of the template.",
      {
        code: z
          .string()
          .describe(
            "The C# code to execute in Revit. This code will be inserted into the Execute method of a template with access to Document and parameters."
          ),
        parameters: z
          .array(z.any())
          .optional()
          .describe(
            "Optional execution parameters that will be passed to your code"
          ),
      },
      async (args, extra) => {
        const params = {
          code: args.code,
          parameters: args.parameters || [],
        };
  
        try {
          const response = await withRevitConnection(async (revitClient) => {
            return await revitClient.sendCommand("send_code_to_revit", params);
          });
  
          return {
            content: [
              {
                type: "text",
                text: `Code execution successful!\nResult: ${JSON.stringify(
                  response,
                  null,
                  2
                )}`,
              },
            ],
          };
        } catch (error) {
          return {
            content: [
              {
                type: "text",
                text: `Code execution failed: ${
                  error instanceof Error ? error.message : String(error)
                }`,
              },
            ],
          };
        }
      }
    );
  }

• src/tools/register.ts:6-72 (registration)

  Dynamic registration entrypoint that scans src/tools directory, imports tool modules like send_code_to_revit.ts, discovers and invokes their register* functions to register all MCP tools with the server.

  export async function registerTools(server: McpServer) {
    // 获取当前文件的目录路径
    const __filename = fileURLToPath(import.meta.url);
    const __dirname = path.dirname(__filename);
  
    console.error('[DEBUG] Starting tool registration from directory:', __dirname);
  
    try {
      // 读取tools目录下的所有文件
      const files = fs.readdirSync(__dirname);
      console.error(`[DEBUG] Found ${files.length} files in tools directory`);
  
      // 过滤出.ts或.js文件，但排除index文件和register文件
      const toolFiles = files.filter((file) => (file.endsWith('.ts') || file.endsWith('.js')) && file !== 'index.ts' && file !== 'index.js' && file !== 'register.ts' && file !== 'register.js');
  
      console.error(`[DEBUG] Filtered to ${toolFiles.length} tool files:`, toolFiles);
  
      // 动态导入并注册每个工具
      const registeredTools = [];
  
      for (const file of toolFiles) {
        try {
          console.error(`[DEBUG] Processing tool file: ${file}`);
          // 构建导入路径
          const importPath = `./${file.replace(/\.(ts|js)$/, '.js')}`;
          console.error(`[DEBUG] Import path: ${importPath}`);
  
          // 动态导入模块
          const module = await import(importPath);
          console.error(`[DEBUG] Module imported successfully with keys:`, Object.keys(module));
  
          // 查找并执行注册函数
          const registerFunctionName = Object.keys(module).find((key) => key.startsWith('register') && typeof module[key] === 'function');
  
          if (registerFunctionName) {
            console.error(`[DEBUG] Found register function: ${registerFunctionName}`);
            await module[registerFunctionName](server);
            console.error(`[DEBUG] Registered tool from file: ${file}`);
            registeredTools.push(file);
          } else {
            console.warn(`[DEBUG] WARNING: No register function found in file ${file}. Available exports:`, Object.keys(module));
          }
        } catch (error) {
          console.error(`[DEBUG] ERROR registering tool ${file}:`, error);
        }
      }
  
      console.error(`[DEBUG] Successfully registered ${registeredTools.length} tools:`, registeredTools);
  
      // List all registered tools by tools' names
      try {
        // This is a workaround as we don't have direct access to registry in the type definitions
        const anyServer = server as any;
        if (anyServer.registry && typeof anyServer.registry.getTools === 'function') {
          const registeredToolNames = anyServer.registry.getTools().map((t: any) => t.id);
          console.error(`[DEBUG] Server has ${registeredToolNames.length} registered tools:`, registeredToolNames);
        } else {
          console.error('[DEBUG] Could not access server registry to list tools');
        }
      } catch (err) {
        console.error('[DEBUG] Error trying to list registered tools:', err);
      }
    } catch (error) {
      console.error('[DEBUG] ERROR during tool registration process:', error);
      throw error;
    }
  }