Summary of the active Fusion document: design_type (parametric/direct), bodies/sketches/features count, units, dirty flag, components, parameters, timeline. A direct design returns parameters_count and timeline_count as None, listed in result.unavailable.

List recently-open documents in Fusion.

List all projects (hubs / folders) the user can see.

Fuzzy-search documents by name. Optional project scope.

Open a document by name (fuzzy). Optional project scope.

Save the active document. Untitled docs are refused by Fusion; use save_as instead.

Save the active document to a new path. Fusion's MCP may still require initial save via UI.

Close the active document. confirm must be 'save', 'discard', or 'prompt'. Never auto-pick save vs discard for dirty docs; surface the choice to the user.

Undo the last count actions. WARNING: undo is atomic on the prior execute call. Mixed-content scripts get fully wiped. Prefer delete-loop cleanup when possible.

Redo the last count undone actions.

Add user parameters idempotently. Existing names are skipped, not overwritten.

Each def: {name, expression, units?, comment?}. Reserved math names (sin/cos/pi/e/sqrt/etc) are rejected at validation time because Fusion will silently bind expressions to the math function.

Update one user parameter's expression. Returns before/after values.

List all user parameters with resolved values, expressions, units, comments.

Create a new sketch on a principal plane. plane in {xy, xz, yz}. name must be unique.

Add a single line to a sketch. p1, p2 are [x, y] in mm.

Add a rectangle to a sketch. kind in {center, corner, 3pt}. Returns line_indices for the 4 edges. center: p1=center point, p2=corner. corner: p1, p2 are opposite corners. 3pt: p1, p2 define one edge, p3 sets the other edge direction.

Add a circle. kind=center_radius needs center+radius_mm. kind=3pt needs p1+p2+p3. Returns circle_index for later reference.

Add a regular polygon. sides >= 3. Inscribed (default) means vertices lie on the radius.

Apply a geometric constraint. kind in {horizontal, vertical, parallel, perpendicular, coincident, tangent, equal, concentric, fix, midpoint, symmetric}. entities is a list of entity refs like 'line:0', 'line:0:start', 'circle:1:center', or 'origin'.

Add a dimension with an expression. kind in {distance_h, distance_v, distance, angle, radial, diameter}. Parameter-name expressions ('body_width', 'length / 2') work AND propagate when the param changes (gotchas.md G9, verified 2026-05-31). Use literal mm only when you want a baked value.

entities depends on kind: distance_h / distance_v / distance: 2 point refs (e.g. ['line:0:start', 'line:0:end']) angle: 2 line refs radial / diameter: 1 circle or arc ref

Check that the sketch has the expected number of closed profiles. Returns ok=False if not. Use after building a sketch to catch self-intersecting polygons (which return profiles=2 silently).

Dump every dimension in a sketch with parameter name, expression, value, and entity-attachment coordinates.

Use this to identify which literal-named dim (e.g. d278) controls which geometric feature when sketches use baked-in numbers. Walks root + every sub-component to find the sketch; pass component_name for disambiguation when the same sketch name exists in multiple components.

Per-dim payload: dim_class, param_name, expression, value_mm, unit, entity_one, entity_two. Entity descriptors include point/start/end/center coords in mm so you can match dims to specific lines/circles/ellipses.

Change a sketch dimension's expression by parameter name (e.g. d278).

Triggers design.computeAll() before returning. After calling this, run audit_feature_health to check whether the edit broke any downstream features (very common for fillets when their target edges move; see G11).

On dim_not_found, the response includes the available dimensions in the sketch so the agent can correct course without another tool call.

Args: sketch: Sketch name (will search root + every sub-component). dim_name: Parameter name of the dimension (use probe_sketch_dimensions to find these). new_expression: New expression as a string. Can be a numeric literal ("20 mm"), a user param reference ("oval_x"), or an expression ("oval_x / 2 + 1 mm"). Units required if not a bare expression. component_name: Optional disambiguation when the sketch name exists in multiple components.

Add an ellipse defined by center + major-axis endpoint + minor-axis endpoint. All in mm.

Add an arc. kind in {3pt, center_start_end, center_start_sweep}. 3pt: p1, p2, p3. center_start_end: center, start, end. center_start_sweep: center, start, sweep_radians (positive = CCW).

Add a fitted spline through a list of [x, y] points (mm). Optionally closed.

Extrude a sketch profile into a feature. operation: new_body | join | cut | intersect | new_component extent_kind: distance (needs expression) | symmetric (needs expression) | all_positive | all_negative direction: positive | negative (for distance kind) participants: body names to operate on (for cut/join/intersect) Returns feature_name + bodies_added.

Fillet edges of a body by geometric filter (no UI selection needed). parallel_to: x | y | z | any — only edges parallel to that axis (or all). radius: expression like 'corner_r' or '8 mm'. min_length_mm: optional minimum edge length filter (skips tiny rounding edges).

Chamfer edges of a body by geometric filter. kind: equal (one distance) | two_dist (needs distance2) | dist_angle (needs angle).

Mirror a feature or body across a plane. plane: xy | xz | yz | .

Rectangular pattern. x_axis / y_axis: x | y | z | . x_distance / y_distance: total-extent expressions like '40 mm' or '4 * pitch'.

Circular pattern around an axis. axis: x | y | z | .

Boolean combine. operation: join | cut | intersect. keep_tools: preserve tool bodies after op.

Revolve a sketch profile around an axis. axis: x | y | z | extent_kind: full (360deg) | angle (needs angle expr) operation: new_body | join | cut | intersect | new_component

Hollow out a body. face_normals_to_remove is a list of [nx, ny, nz] for faces to remove (e.g. [[0, 0, 1]] removes the top face). Empty / omitted = closed shell. direction: inside | outside | both.

Add a hole on the body's top face (max-Z, +Z normal). kind: simple | counterbore (needs cbore_diameter + cbore_depth) | countersink (needs csink_diameter + csink_angle). position_mm: [x, y, z] — x/y locate on the top face; z is informational. extent_kind: all | distance (needs depth_expression).

Rebuild a feature whose downstream references are stale (G10) by capturing its inputs, deleting it, and re-creating from the current sketch.

Supported feature classes: ExtrudeFeature (DistanceExtent, ProfilePlaneStart or OffsetStart, 1 or N profiles in the same sketch). This is the most common G10 case — a feature that got healthState=1 (warning, using cached geometry) after a sketch geometry rewrite.

Returns structured not_supported_for_rebuild error for other feature classes (fillet, chamfer, hole, revolve, etc.) with a recommendation:

• FilletFeature/ChamferFeature broken by upstream edits: SUPPRESS instead (gotcha G11; edge re-binding is design-specific geometric matching).

• Others: delete + re-create via the appropriate add_* tool.

Profile matching: when the original sketch has more than one profile, picks the new profile whose area is closest to the captured original area. Falls back to profile[0] if no area was captured.

Failure mode warning: if delete succeeds but recreate fails (e.g., sketch name changed, multiple profiles spread across sketches), the response sets ok=false and includes a WARNING field instructing the agent to undo via Fusion's undo and try again manually.

Args: feature_name: Name of the feature to rebuild. Walks root + every sub-component. component_name: Optional hint for disambiguation.

Chain pattern: edit_sketch_dimension -> audit_feature_health -> for each broken extrude in features list, rebuild_feature -> audit_feature_health.

Move a body via a Move feature (parametric in the timeline). Provide translation_mm (mm) and/or rotation (axis + angle_deg).

NOT SCRIPTABLE in the current Fusion API: RibFeatures is a read-only collection (no createInput/add), so this always returns the structured error rib_not_scriptable. Model ribs as thin join-extrudes instead.

Convert root-level bodies into named components, preserving world position. mapping is {body_name: new_component_name}. Multi-body designs need this before joint/motion work — Fusion's joints operate on components, not bodies.

Move an occurrence by translation (mm) and/or rotation (axis + angle deg). rotation_origin_mm defaults to [0, 0, 0] (world origin) if omitted. Breaks the occurrence's ground-to-parent flag if set (otherwise the move silently reverts). Check moved and after_translation_mm in the response; a joint solver can override the requested move.

Set the ground flag on an occurrence (lock its world position).

Clear the ground flag on an occurrence.

Lock 2+ components together as a rigid group (they move as one).

Create a contact set for physics / motion analysis between 2+ bodies.

Run an interference analysis on 2+ bodies or occurrences. Returns per-pair interference volume in mm^3. Empty pair list = no interference.

Set min/max/rest values on an existing joint by name. Values are expressions: angles for revolute (e.g. '45 deg'), distances for slider. rest_value is the NEW May 2026 snap-back position. Pass None to leave any field unset. Limits bind to rotationLimits when the motion has one, else slideLimits (cylindrical joints get rotation limits). The response echoes back what Fusion actually stored under applied (internal units: radians / cm).

Drive an existing joint to a target value. value is an expression: angle for revolute, distance for slider, etc. Tries jointMotion attributes in order: rotation, slide, roll, pitch, yaw. Fusion silently ignores drives beyond the joint's limits; check applied in the response (false = the joint stayed where it was).

Create a Joint between two entity-handle origins.

Joint origins are specified as entity handles (kind:path:token). Supported kinds: face (planar OR cylindrical/conical), edge (uses MiddleKeyPoint), vertex (uses Point), point (sketch point). Get handles from list_body_entities for face/edge/vertex, or use the sketch tools' returned handles for sketch points.

motion_type: one of rigid, revolute, slider, cylindrical, ball.

• rigid: locks the two origins; no DOF

• revolute: 1 DOF rotation about axis (use for hinges)

• slider: 1 DOF translation along axis

• cylindrical: rotation + translation along axis

• ball: 3 DOF rotation (axis arg ignored; Fusion only accepts pitch=Z, yaw=X, which is what gets used)

axis: x | y | z, relative to the first joint geometry's local frame. For typical face-normal rotation (hinge pin coming out of the face) use z.

offset_mm: optional ValueInput expression for lateral offset between the two geometries. A snap hinge typically needs a few mm here to hold the gap between mating flanges. Preserved across user-param changes (unlike Move-based positioning).

angle_deg: optional initial angle (revolute / cylindrical).

name: optional joint name in the timeline.

Returns {ok, joint_name, joint_token, motion_type, axis, offset_mm, angle_deg}. Use joint_name for downstream drive_joint / set_joint_limits calls.

Errors:

• handle_invalid: one of the geometry handles could not be resolved.

• joint_geometry_failed: face/edge/vertex/point handle resolved but Fusion could not build a JointGeometry from it (e.g. degenerate face).

• joints_add_failed: joint inputs were valid but Fusion refused the joint (usually means the two geometries are mateable only with a different motion type, or one geometry is in a frozen component).

Create a construction plane. kind in {offset, midplane, at_angle, 3_points}. offset: base_plane + offset expr (e.g. 'thickness') midplane: plane_a + plane_b (between two existing planes) at_angle: axis + base_plane + angle expr (e.g. '30 deg') 3_points: p1, p2, p3 each as [x, y, z] in mm Plane / axis names default to principals: 'xy', 'xz', 'yz' / 'x', 'y', 'z'.

Create a construction axis. kind in {2_points, normal_to_face_by_geometry}. 2_points: p1, p2 each as [x, y, z] in mm normal_to_face_by_geometry: body name + face_normal [nx, ny, nz] (finds the face whose normal matches)

Create a construction point at explicit [x, y, z] coordinates (mm).

Delete a construction plane / axis / point by name.

Enumerate faces / edges / vertices of a body and return their handles. This is the bridge between name-addressing (bodies) and handle-addressing (sub-entities).

kinds: subset of [face, edge, vertex]. Defaults to all three. face_normal_filter: [nx, ny, nz] — only faces matching that normal (e.g. [0, 0, 1] for top). edge_parallel_to: x | y | z — only axis-parallel edges. min_edge_length_mm: filter out short edges (typical use: skip fillet runouts).

Returns face/edge/vertex lists, each with handle, index, and geometric info. Use the returned handles in measure, fillet_edges, chamfer_edges, project_to_sketch, etc.

Measure between two entities using their handles (from list_body_entities or tool returns). kind: distance (min distance + nearest points) | min_distance (value only) | angle.

NEW May 2026: cast a ray and return MeshBody objects intersected. origin_mm: ray origin [x, y, z] in mm. direction: ray direction [dx, dy, dz] (any magnitude; will be normalized by Fusion). component_name: optional component to scope the search; omit for whole root.

NEW May 2026: cast a ray against ONE MeshBody, return all intersection points. mesh_handle: handle of a mesh body (e.g. from find_mesh_using_ray or list_body_entities).

Fillet specific edges by handle (UI-selection style). edge_handles: list from list_body_entities (kinds=['edge']). radius: expression like 'corner_r' or '8 mm'.

Chamfer specific edges by handle. kind: equal | two_dist (needs distance2) | dist_angle (needs angle).

Project entities (by handle) onto a named sketch. Useful for cut-extrudes that reference body geometry.

Return mm bbox + extents for a body (by name) or all bodies if name omitted. Walks root + every occurrence.

Return volume in cm^3 and mm^3 for a body (by name) or all bodies if name omitted.

Return mass (kg), material name, density, and volume for a body or all bodies. Material is whatever the body has been assigned; uses Fusion's physical-properties calc.

Return center of mass in mm world coordinates for a body or all bodies.

Sweep the feature tree (root + every sub-component) and report features whose healthState != 0.

Call this after ANY tool that edits sketch geometry, user parameters, or features. If summary.failed > 0 (state 2 or 3) or summary.warning > 0 (state 1), the BREP may look healthy via the API while Fusion's UI shows a stale cached display. See gotchas G10/G11.

Args: component_name: Restrict the audit to features in this component (still recurses into its sub-components). Default: root + all. include_healthy: Include healthy features (state 0) in the features list. Default False — only broken features are returned.

Returns envelope.result = { ok, summary: {total, healthy, warning, failed}, features: [{path, component, name, classType, healthState, healthLabel, isSuppressed, errorOrWarningMessage}, ...] }

Capture a PNG screenshot of the active viewport. Returns base64 image in envelope.image. direction: one of current, front, back, bottom, top, left, right, iso-* (4 variants). Fusion handles fit-view internally for named directions.

Orient the viewport to a named direction. Optionally fit to view. Use when you want to change camera without capturing a screenshot.

Capture before/after screenshots from the same camera by rolling the timeline marker to before_marker_position, screenshotting, restoring the original marker position, and screenshotting again.

Use this to give yourself or the user a clean visual diff of a change you just made — much more convincing than describing the change in words when the geometric delta is subtle. Same camera both shots so the comparison is honest.

Restore semantics: if anything fails after the marker is moved, this tool attempts to roll back to the original position before returning. The restore_marker_failed error indicates the rollback itself failed — in that case the design may be left at an intermediate marker position and the user should manually drag the marker back.

Args: before_marker_position: Timeline marker position to capture as the "before" state. Must be in [0, timeline.count]. Use 0 for the initial empty state, or the index just before a specific feature. direction: One of: current, front, back, bottom, top, left, right, iso-bottom-left/right, iso-top-left/right. Defaults to iso-top-right. width, height: Optional image dimensions in pixels. transparent: PNG transparency. Default True. anti_aliasing: Smooth edges. Default True.

Returns envelope.result = { before_image: {data: , mime_type: "image/png"}, after_image: {data: , mime_type: "image/png"}, before_marker, after_marker, direction }

Search the local Fusion API help corpus.

Returns top-N matches as {slug, title, namespace, kind, url, is_preview, introduced, snippet}. Use this BEFORE writing a script that touches an unfamiliar method or class.

Filters: kind: 'object' | 'member' | 'manual' | etc — restrict to one page type namespace: substring match on namespace (e.g. 'Fusion', 'CAM', 'core')

Search patterns.md (verified Fusion MCP patterns and helpers) by intent.

Use when looking for the canonical idiom for a common operation (constrained rectangle, fillet by geometry, screenshot fit-view, etc).

Search this server's own tool reference (tools.md) by intent or symptom.

Returns the matching sections: signatures, exact enum values, return keys, and error codes. Use this to look up how to call a tool instead of guessing at arguments, and to check what an error code means.

Works with Fusion closed.

Search gotchas.md (known failure modes) by symptom or keyword.

Use when something behaves unexpectedly: check here for the documented cause

• fix before debugging from scratch.

Export geometry to a file. format in {stl, 3mf, step, iges, obj, f3d, sat, smt}. path: absolute path (relative + '..' + Windows reserved names rejected). body: optional body name. If omitted, exports the whole root component. STEP/IGES/SAT/SMT/F3D always export the whole design (ignore body). refinement: low | medium | high — applies to STL and OBJ mesh quality. units: mm | cm | m | inch — STL/OBJ only.

Import geometry from a file into the active design. format in {step, iges, sat, smt, f3d}. path: absolute path to an existing file. Returns counts of bodies and occurrences added to the root component.

Raw Python passthrough. The script must define def run(_ctx): as entry point. Use print() for any data to return; stdout becomes the response message.