send_code_to_revit

Execute custom C# code in Autodesk Revit to automate BIM workflows, modify project elements, and extend functionality through direct API access.

Instructions

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.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`code`	Yes	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`	No	Optional execution parameters that will be passed to your code

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;
  }
}

Revit MCP Server