@rui.branco/revit-mcp 1.0.0

package/lib/tools/install.js

@@ -0,0 +1,208 @@
+// Installing the bridge add-in. This is the one pair of tools that must work
+// with Revit closed and the bridge absent — it is how the bridge gets there in
+// the first place — so nothing here touches lib/bridge.js or the HTTP port.
+//
+// The work is done by revit-bridge/install.ps1, which detects Revit and copies
+// the add-in into the Addins folder. The add-in ships prebuilt in
+// revit-bridge/dist/, so the usual path needs no .NET SDK and no build; only a
+// source checkout with no dist/ falls back to `dotnet build -c Release`. We run
+// it with -Json, which makes it print one JSON object and nothing else.
+
+import { spawn } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+
+// Resolved from this module, never from process.cwd(): an MCP server is
+// started by the client from whatever directory it likes.
+export const INSTALL_SCRIPT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "..",
+  "revit-bridge",
+  "install.ps1",
+);
+
+// Installing the bundled add-in is a file copy, but the source-checkout
+// fallback still shells out to dotnet build, which on a cold NuGet cache is
+// minutes, not seconds.
+export const INSTALL_TIMEOUT_MS = 300000;
+
+// PowerShell 7 if it is there, Windows PowerShell otherwise — the script is
+// written to run under both.
+const SHELLS = ["pwsh.exe", "powershell.exe"];
+
+// install.ps1 exits with a code per failure mode, so none of them has to be
+// guessed at from the prose.
+export function explainExitCode(code, action = "install") {
+  switch (code) {
+    case 0:
+      if (action === "uninstall") return "Success: the add-in was removed. Restart Revit to unload it.";
+      return "Success: the add-in is installed. Revit must be RESTARTED before the bridge works — Revit only scans the Addins folder at startup.";
+    case 1:
+      return "The installer hit an unhandled failure. The `errors` and `log` fields say what threw.";
+    case 2:
+      if (action === "uninstall")
+        return "Nothing to uninstall: no Revit installation and no Revit Addins folder was found, so there was nothing to remove. Not a failure.";
+      return "No Revit installation was found under Program Files\\Autodesk. Install Revit, or pass revit_version to target a version installed somewhere else.";
+    case 3:
+      return "No supported Revit version. This add-in is .NET 8 and needs Revit 2025 or newer; Revit 2024 and earlier load add-ins on .NET Framework 4.8 and cannot run it. A revit_version that is not a four-digit year also lands here.";
+    case 4:
+      return "`dotnet build` failed, or the .NET SDK is not installed, so nothing was installed. This only happens in a source checkout with no prebuilt revit-bridge/dist/ — the published package ships one. The build output is in `log`.";
+    case 5:
+      return "Nothing to install: no prebuilt add-in in revit-bridge/dist/ and no Release build output either. Re-run without skip_build so the add-in gets built, or reinstall the package to restore the bundled binary.";
+    default:
+      return `install.ps1 exited with code ${code}.`;
+  }
+}
+
+// Argv, never a command string: a path with a space in it must not become two
+// arguments, and nothing here may be shell-interpreted.
+export function installerArgv(
+  { uninstall = false, revitVersion, skipBuild } = {},
+  scriptPath = INSTALL_SCRIPT,
+) {
+  const argv = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", scriptPath];
+  if (uninstall) argv.push("-Uninstall");
+  if (revitVersion) argv.push("-RevitVersion", revitVersion);
+  if (skipBuild) argv.push("-SkipBuild");
+  argv.push("-Json");
+  return argv;
+}
+
+function runShell(exe, argv, spawnImpl, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawnImpl(exe, argv, { windowsHide: true });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    // Stop waiting rather than waiting for the kill to land: a dotnet build
+    // that outlives the timeout must not hold the tool call open too.
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve({ exe, code: null, stdout, stderr, timedOut });
+    }, timeoutMs);
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => (stdout += chunk));
+    child.stderr.on("data", (chunk) => (stderr += chunk));
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ exe, code, stdout, stderr, timedOut });
+    });
+  });
+}
+
+async function runAnyShell(argv, spawnImpl, timeoutMs) {
+  let lastError;
+  for (const exe of SHELLS) {
+    try {
+      return await runShell(exe, argv, spawnImpl, timeoutMs);
+    } catch (err) {
+      // Only "that executable does not exist" is worth falling back on.
+      if (err.code !== "ENOENT") throw err;
+      lastError = err;
+    }
+  }
+  throw new Error(
+    `Could not start PowerShell: neither ${SHELLS.join(" nor ")} could be launched (${lastError.message}). The Revit bridge only installs on Windows.`,
+  );
+}
+
+// -Json promises a single JSON object as the only stdout. Anything else means
+// the script died before it got there, and the raw output is the evidence.
+function parseResult(stdout) {
+  try {
+    const parsed = JSON.parse(stdout.trim());
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export async function runInstaller(
+  options = {},
+  { spawnImpl = spawn, scriptPath = INSTALL_SCRIPT, timeoutMs = INSTALL_TIMEOUT_MS } = {},
+) {
+  const action = options.uninstall ? "uninstall" : "install";
+  const run = await runAnyShell(installerArgv(options, scriptPath), spawnImpl, timeoutMs);
+
+  if (run.timedOut) {
+    return {
+      ok: false,
+      action,
+      timedOut: true,
+      timeoutMs,
+      message: `install.ps1 has not finished after ${timeoutMs}ms. This is not a failure: 'dotnet build' can take longer than that on a cold NuGet cache, and the build it started may still be finishing. Wait a minute and run this tool again — re-running is safe — or check ${scriptPath} manually.`,
+      stdout: run.stdout,
+      stderr: run.stderr,
+    };
+  }
+
+  const parsed = parseResult(run.stdout);
+
+  if (!parsed) {
+    return {
+      ok: false,
+      action,
+      exitCode: run.code,
+      explanation: explainExitCode(run.code, action),
+      message: "install.ps1 did not print the JSON object -Json promises. Its raw output follows.",
+      stdout: run.stdout,
+      stderr: run.stderr,
+    };
+  }
+
+  return { ...parsed, exitCode: run.code, explanation: explainExitCode(run.code, action) };
+}
+
+export function registerInstallTools(server, options = {}) {
+  server.tool(
+    "revit_install_bridge",
+    "Install the Revit MCP bridge add-in: copies the add-in that ships with this package into Revit's Addins folder. No .NET SDK and no build step are involved. Use this when revit_status says nothing is listening, or on a machine where the bridge has never been set up. Revit does NOT need to be running. RESTART REVIT after this succeeds — Revit only scans the Addins folder at startup, so the bridge does not load until Revit is restarted. Re-running is safe.",
+    {
+      revit_version: z
+        .string()
+        .optional()
+        .describe("Four-digit Revit year, e.g. '2026'. Omit to install into every Revit found on this machine."),
+      skip_build: z
+        .boolean()
+        .optional()
+        .describe("Never build, even in a source checkout with no prebuilt add-in. A no-op for the published package, which always installs its bundled binary without building."),
+    },
+    async ({ revit_version, skip_build }) => {
+      try {
+        const result = await runInstaller(
+          { revitVersion: revit_version, skipBuild: skip_build },
+          options,
+        );
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_uninstall_bridge",
+    "Remove the Revit MCP bridge add-in: deletes the .addin manifest and the install folder for every Revit version that has it. Revit does NOT need to be running, but RESTART REVIT afterwards — a running Revit keeps the already-loaded bridge alive until it closes.",
+    {},
+    async () => {
+      try {
+        const result = await runInstaller({ uninstall: true }, options);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+}

package/lib/tools/material-appearance.js

@@ -0,0 +1,168 @@
+// The rendered look behind a material: its appearance asset.
+//
+// revit_create_material and revit_set_material_texture author a look. These two
+// read and edit the one a material already has, which is what "this stucco is
+// too pale" and "take the orange out of the window frames" actually need.
+//
+// An appearance asset has no fixed set of properties: what it carries depends
+// on the SCHEMA it was built from — a Generic asset has "generic_diffuse",
+// "generic_glossiness" and "generic_transparency"; a Ceramic one has
+// "ceramic_color"; a Water one has neither. So there is no guessing here:
+// revit_get_material_appearance lists what the asset really has, with the type
+// of each property, and revit_set_material_appearance writes the properties you
+// name, by the type you name, or fails the whole call.
+//
+// Two rules the bridge does not bend, and they are worth knowing before you
+// call it:
+//
+//   - The asset is DUPLICATED before it is patched. Two materials very often
+//     share one appearance asset, and editing it in place repaints both.
+//   - A patch that does not fit — an unknown property, the wrong type, a value
+//     Revit's own IsValidValue refuses — rolls the entire request back. It
+//     never reports success for a change that did not happen.
+//
+// That second rule is why both catches answer with `isError: true`: a rolled
+// back patch reaches here as a bridge exception, and without the flag an MCP
+// client reads it as a successful call whose text happens to start with
+// "Error:".
+
+import { z } from "zod";
+
+const CHANNEL = z.number().int().min(0).max(255);
+
+const RGB = z.object({ r: CHANNEL, g: CHANNEL, b: CHANNEL });
+
+// Named the same way as every other material tool: material_id wins, and
+// material_name is the alternative. Neither is required here — the bridge is
+// what says so, with the message that names the endpoint to call instead.
+const MATERIAL = {
+  material_id: z
+    .number()
+    .int()
+    .optional()
+    .describe("Material id from revit_list_materials or revit_create_material"),
+  material_name: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Material name, as an alternative to material_id. Must already exist in the document."),
+};
+
+export function registerMaterialAppearanceTools(server, bridge) {
+  server.tool(
+    "revit_get_material_appearance",
+    "Read the appearance asset behind a material — the rendered look, as opposed to the shading colour revit_create_material sets. Read-only: it changes nothing. It reports the material's shading side (colorRgb, transparency, shininess, smoothness, useRenderAppearanceForShading), the AppearanceAssetElement it really points at (id, name and the SCHEMA it was built from, e.g. 'Generic' or 'Ceramic'), and every direct property of that asset: 'name' as the API knows it (e.g. 'generic_diffuse'), 'type' and 'runtimeType', the typed 'value' it holds, and 'patchType' — which of revit_set_material_appearance's five types can write it, or null when none can. Anything connected to a property comes back under 'connected' with the bitmap's file, tile size in feet and rotation. 'sharedWithMaterialIds' is every OTHER material pointing at the same asset: non-empty means editing it in place would repaint them too, which is exactly what revit_set_material_appearance refuses to do. NOTE on 'readOnly': Revit hands the rendering asset out read-only outside an edit scope, so it is usually true for every property and is NOT the test of whether a property can be written — revit_set_material_appearance is, because it validates inside an edit scope. A material with no appearance asset at all is a normal state, not a broken one: it renders from Color and Transparency alone, appearanceAssetId comes back null with an empty property list, and it does NOT need a bitmap — create_generic on revit_set_material_appearance gives it a textureless Generic asset to patch. 'genericAssetAvailable' says up front whether Revit's library can supply one on this machine.",
+    MATERIAL,
+    async ({ material_id, material_name }) => {
+      try {
+        const result = await bridge.call("/materials/appearance", {
+          materialId: material_id,
+          materialName: material_name,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_set_material_appearance",
+    "Edit the appearance asset behind a material by naming the properties to write. Call revit_get_material_appearance FIRST: every patch names a property of the asset's own schema ('generic_diffuse', 'generic_glossiness', ...), and a name that schema does not have fails the call instead of quietly doing nothing. Each patch is {name, type, value} where type is 'color', 'double', 'integer', 'boolean' or 'string' — the type is checked against the property's real runtime type and the value against Revit's own IsValidValue, and one patch that does not fit rolls the WHOLE request back. Colours are {r, g, b} with each channel 0-255, which Revit stores inside the asset as doubles 0-1; both come back in the readback. The asset is DUPLICATED before it is patched (duplicate defaults to true), because materials very often share one and editing it in place would repaint every one of them — 'duplicate': false is refused with SHARED_APPEARANCE_ASSET when anybody else points at it, and there is deliberately no way to force a shared edit. 'sharedWithMaterialIds' in the reply is computed against the RESULTING asset, so an empty list is the evidence nothing leaked. source_appearance_asset_id duplicates another material's asset onto this one (the source keeps its look). create_generic gives a material with NO appearance asset a textureless Generic asset built from Revit's own library — a null appearance asset never means the material needs a bitmap — and answers GENERIC_ASSET_UNAVAILABLE when the material libraries are not installed. disconnect_texture only matters for a 'color' patch and only when explicitly true: a colour written under a connected bitmap renders as nothing, so that patch is refused unless you say to remove the texture. sync_shading_color also copies the first patched colour onto the material's own Color, which is what SHADED views draw when useRenderAppearanceForShading is false; otherwise the shading colour the material had is preserved, even when Revit would have repainted it to match a new asset. The reply carries 'applied', 'verified' (the committed asset read back), the resulting appearanceAssetId and the asset it replaced. One call is one undo step.",
+    {
+      ...MATERIAL,
+      patches: z
+        .array(
+          z.object({
+            name: z
+              .string()
+              .min(1)
+              .describe(
+                "Asset property name, exactly as revit_get_material_appearance lists it, e.g. 'generic_diffuse'",
+              ),
+            type: z
+              .enum(["color", "double", "integer", "boolean", "string"])
+              .describe(
+                "Type to write it as. It must match the property's 'patchType' from revit_get_material_appearance.",
+              ),
+            value: z
+              .union([RGB, z.number(), z.boolean(), z.string()])
+              .describe(
+                "The value: {r, g, b} 0-255 for 'color', a number for 'double' and 'integer', true/false for 'boolean', text for 'string'",
+              ),
+          }),
+        )
+        .optional()
+        .describe(
+          "Properties to write, all in this one call. Optional only when create_generic or source_appearance_asset_id is given; otherwise the call has nothing to do and is refused.",
+        ),
+      duplicate: z
+        .boolean()
+        .optional()
+        .describe(
+          "Duplicate the asset before patching it. Defaults to true. False edits in place and is refused when another material shares the asset.",
+        ),
+      source_appearance_asset_id: z
+        .number()
+        .int()
+        .optional()
+        .describe(
+          "Id of an appearance asset to start from, from revit_list_materials or revit_get_material_appearance. It is duplicated and the copy assigned to THIS material only, so the material it came from is untouched.",
+        ),
+      create_generic: z
+        .boolean()
+        .optional()
+        .describe(
+          "Give the material a new textureless Generic appearance asset from Revit's library and patch that. This is the route for a material whose appearanceAssetId is null.",
+        ),
+      disconnect_texture: z
+        .boolean()
+        .optional()
+        .describe(
+          "Remove a bitmap connected to a property being patched as a colour, so the colour is what renders. Only applies to 'color' patches, and only when explicitly true.",
+        ),
+      sync_shading_color: z
+        .boolean()
+        .optional()
+        .describe(
+          "Also write the first patched colour onto the material's own Color, which is what shaded views draw. Needs at least one 'color' patch.",
+        ),
+    },
+    async ({
+      material_id,
+      material_name,
+      patches,
+      duplicate,
+      source_appearance_asset_id,
+      create_generic,
+      disconnect_texture,
+      sync_shading_color,
+    }) => {
+      try {
+        // The tool arguments stay snake_case like every other tool's; the bridge
+        // reads materialId / sourceAppearanceAssetId / ... — map them here rather
+        // than on the C# side. A patch keeps its {name, type, value} shape on the
+        // wire, because those three are the contract on both sides.
+        const result = await bridge.call("/materials/set-appearance", {
+          materialId: material_id,
+          materialName: material_name,
+          patches,
+          duplicate,
+          sourceAppearanceAssetId: source_appearance_asset_id,
+          createGeneric: create_generic,
+          disconnectTexture: disconnect_texture,
+          syncShadingColor: sync_shading_color,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error.message}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+}

package/lib/tools/materials.js

@@ -0,0 +1,247 @@
+// Materials, and the wall and floor types that carry one.
+//
+// Nothing else here set a material, so everything the bridge built rendered in
+// Revit's default grey. There are two routes onto an element and they are not
+// interchangeable:
+//
+//   - Geometry built by revit_create_directshape, revit_place_planting,
+//     revit_create_pipes and revit_place_sprinklers carries its material on the
+//     solid. That is decided when the solid is built, so those tools take a
+//     material_id and revit_assign_material cannot help them afterwards.
+//   - A wall or a floor takes its material from its TYPE's compound structure:
+//     revit_create_wall_type / revit_create_floor_type author one, and
+//     revit_create_walls / revit_create_floor build with it by name.
+//
+// revit_assign_material covers what is left: elements with a real material
+// parameter, and walls/floors whose type it can edit. It says per element which
+// route it used, and which elements could take neither.
+//
+// Colour channels are 0-255; transparency is 0-100 and shininess 0-128, which
+// are Revit's own ranges. Thickness is feet, like every other length here.
+//
+// A colour on its own is still flat paint. revit_set_material_texture is what
+// puts a real bitmap on a material — grass that looks like grass rather than
+// like green — and Revit ships the bitmaps to do it with, under
+// C:\Program Files\Common Files\Autodesk Shared\Materials\Textures.
+
+import { z } from "zod";
+
+const MATERIAL_CHANNEL = z.number().int().min(0).max(255);
+
+// Shared by the two type tools: they differ only in which type kind they make.
+const HOST_TYPE = {
+  name: z.string().min(1).describe("Name for the new type. Must be unique among types of this kind."),
+  based_on_type_name: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Existing type to duplicate. Omit it to duplicate the document's default type."),
+  thickness: z
+    .number()
+    .positive()
+    .optional()
+    .describe("Thickness of the single structural layer, in feet. Omit it to keep the source type's."),
+  material_id: z
+    .number()
+    .int()
+    .optional()
+    .describe("Material id for that layer, from revit_list_materials or revit_create_material."),
+  material_name: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Material name, as an alternative to material_id. Must already exist in the document."),
+};
+
+export function registerMaterialTools(server, bridge) {
+  server.tool(
+    "revit_list_materials",
+    "List the materials in the document: id, name, colour as {r, g, b}, and the id of its appearance asset when it has one. This is where a material_id comes from — for revit_create_directshape, revit_place_planting, revit_create_pipes, revit_place_sprinklers, revit_assign_material, revit_create_wall_type and revit_create_floor_type. A Revit template usually ships dozens, so check here before creating a new one.",
+    {},
+    async () => {
+      try {
+        const result = await bridge.call("/materials", {});
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_create_material",
+    "Create a material with a colour, so the model stops rendering in Revit's default grey. 'color' is {r, g, b}, each 0-255. 'transparency' is 0-100 (0 is opaque — use it for water and glass) and 'shininess' is 0-128; omitted, Revit's own defaults are left alone. A material that already exists by this name is REUSED and comes back with created:false and its current properties — nothing about it is overwritten, so re-running the same call is safe, and a colour you did not ask for means somebody else authored that material. Shading is set to follow the colour rather than a render appearance, which is what makes the colour visible in a shaded view. 'appearance_asset_id' takes the look of an existing material's appearance asset (see revit_list_materials): it is duplicated, not shared. 'texture_path' puts a real bitmap on it in the same call — what that did comes back under 'texture'; it is ignored for a material that already exists, which revit_set_material_texture can texture instead.",
+    {
+      name: z.string().min(1).describe("Material name, e.g. 'Relva' or 'Betão pigmentado'"),
+      color: z
+        .object({ r: MATERIAL_CHANNEL, g: MATERIAL_CHANNEL, b: MATERIAL_CHANNEL })
+        .describe("Colour as {r, g, b}, each channel 0-255"),
+      transparency: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("Transparency 0-100; 0 is opaque. Omit it to keep Revit's default."),
+      shininess: z
+        .number()
+        .int()
+        .min(0)
+        .max(128)
+        .optional()
+        .describe("Shininess 0-128. Omit it to keep Revit's default."),
+      surface_foreground_pattern_id: z
+        .number()
+        .int()
+        .optional()
+        .describe("Id of a FillPatternElement to use as the surface foreground pattern"),
+      appearance_asset_id: z
+        .number()
+        .int()
+        .optional()
+        .describe(
+          "Id of an AppearanceAssetElement to copy the rendered look of, from revit_list_materials. It is duplicated so later edits cannot leak between materials.",
+        ),
+      texture_path: z
+        .string()
+        .min(1)
+        .optional()
+        .describe(
+          "Full path to a texture bitmap, to make the material textured in this same call. Revit's own library is under C:\\Program Files\\Common Files\\Autodesk Shared\\Materials\\Textures. A file that does not exist is refused before anything is created. Tile size, rotation and tint belong to revit_set_material_texture.",
+        ),
+    },
+    async ({
+      name,
+      color,
+      transparency,
+      shininess,
+      surface_foreground_pattern_id,
+      appearance_asset_id,
+      texture_path,
+    }) => {
+      try {
+        const result = await bridge.call("/materials/create", {
+          name,
+          color,
+          transparency,
+          shininess,
+          surfaceForegroundPatternId: surface_foreground_pattern_id,
+          appearanceAssetId: appearance_asset_id,
+          texturePath: texture_path,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_set_material_texture",
+    "Put a real texture bitmap on an existing material, which is the difference between a surface that is green and one that looks like grass. Revit ships thousands of bitmaps under C:\\Program Files\\Common Files\\Autodesk Shared\\Materials\\Textures — pass a full path to one of those, or to any image file this machine can read; it is REFERENCED by the model, not copied into it, so a path that stops existing is a texture that stops rendering. A file that is not there is refused with TEXTURE_NOT_FOUND. 'scale' is the real-world size of one tile of the bitmap, {x, y} in feet — 3 by 3 makes a paving texture read as 3-foot slabs. 'rotation' is degrees and 'tint' is a colour multiplied over the bitmap. The material is given its own Generic appearance asset unless it already has one nobody else shares, so texturing one material can never change another's look; the reply says whether that happened and why. It reports every asset property it wrote under 'set', anything the asset turned out not to have under 'missing', and what the saved asset reads back as under 'verified'. One call is one undo step.",
+    {
+      material_id: z
+        .number()
+        .int()
+        .optional()
+        .describe("Material id from revit_list_materials or revit_create_material"),
+      material_name: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Material name, as an alternative to material_id. Must already exist in the document."),
+      texture_path: z
+        .string()
+        .min(1)
+        .describe(
+          "Full path to the texture bitmap, e.g. 'C:\\Program Files\\Common Files\\Autodesk Shared\\Materials\\Textures\\1\\Mats\\grass_color.jpg'",
+        ),
+      scale: z
+        .object({ x: z.number().positive(), y: z.number().positive() })
+        .optional()
+        .describe(
+          "Real-world size of one tile of the bitmap, {x, y} in feet. Omit it to leave Revit's own tile size.",
+        ),
+      rotation: z.number().optional().describe("Rotation of the texture, in degrees"),
+      tint: z
+        .object({ r: MATERIAL_CHANNEL, g: MATERIAL_CHANNEL, b: MATERIAL_CHANNEL })
+        .optional()
+        .describe("Colour multiplied over the bitmap, as {r, g, b}, each channel 0-255"),
+    },
+    async ({ material_id, material_name, texture_path, scale, rotation, tint }) => {
+      try {
+        const result = await bridge.call("/materials/set-texture", {
+          materialId: material_id,
+          materialName: material_name,
+          texturePath: texture_path,
+          scale,
+          rotation,
+          tint,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_assign_material",
+    "Put an existing material on elements that already exist. Two routes, chosen per element and reported per element: a wall, floor, roof, ceiling or toposolid gets it through its TYPE's compound structure — which changes every element of that type, and the row says so with appliesToType — and anything with a writable material parameter gets it written there. Elements that can take neither come back under 'skipped' with the reason. DirectShape elements (everything from revit_create_directshape, revit_place_planting, revit_create_pipes and revit_place_sprinklers) are always skipped: their material is carried by the solid and fixed when it is built, so pass material_id to those tools instead. One call is one undo step.",
+    {
+      material_id: z.number().int().describe("Material id from revit_list_materials or revit_create_material"),
+      element_ids: z.array(z.number().int()).min(1).describe("Elements to put the material on"),
+    },
+    async ({ material_id, element_ids }) => {
+      try {
+        const result = await bridge.call("/materials/assign", {
+          materialId: material_id,
+          elementIds: element_ids,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_create_wall_type",
+    "Create a wall type carrying a material and a thickness, by duplicating an existing type and giving it a single structural layer. A wall's material is a property of its type, not of the wall, so this is the only way to get walls that are not the template's default grey: create the type, then pass its name to revit_create_walls as wall_type. A type that already exists by this name is REUSED and comes back with created:false and its current thickness and material — it is not re-cut to match the request. Thickness is feet (Revit internal units). One call is one undo step.",
+    HOST_TYPE,
+    async ({ name, based_on_type_name, thickness, material_id, material_name }) => {
+      try {
+        const result = await bridge.call("/walltypes/create", {
+          name,
+          basedOnTypeName: based_on_type_name,
+          thickness,
+          materialId: material_id,
+          materialName: material_name,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+
+  server.tool(
+    "revit_create_floor_type",
+    "Create a floor type carrying a material and a thickness, by duplicating an existing type and giving it a single structural layer. Like walls, a floor's material lives on its type — this is how paving stops being grey: create the type, then pass its name to revit_create_floor as type_name. A type that already exists by this name is REUSED and comes back with created:false and its current thickness and material. Thickness is feet (Revit internal units). One call is one undo step.",
+    HOST_TYPE,
+    async ({ name, based_on_type_name, thickness, material_id, material_name }) => {
+      try {
+        const result = await bridge.call("/floortypes/create", {
+          name,
+          basedOnTypeName: based_on_type_name,
+          thickness,
+          materialId: material_id,
+          materialName: material_name,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    },
+  );
+}