Command catalog¶

Every command an agent may issue, with the payload each one takes. It is the same list get_command_catalog returns at runtime, and describe_commands returns these entries with their full JSON schemas. Both drive the same pipeline the UI does.

execute_command fills in project_id; the other required fields are yours. A command whose type is not on this list is refused before it reaches the model, and so is a payload carrying a field its schema does not define, at any depth (invalid_payload, naming the field).

Generated from the app's catalog at version 0.2.0. Regenerate with make docs-catalog.

assembly.create_child¶

Create a new empty sub-assembly definition and place one occurrence of it inside assembly_id (the parent). Returns the new definition's assembly_id (add parts to it) and the occurrence_id that places it. Editing a definition updates every occurrence of it.

assembly.group.create¶

Bundle children of one assembly (parts, part instances, occurrences) into a named group. A group is organisation only — it carries no transform and no geometry, it just collapses a long tree into one row. Members must belong to that assembly and to no other group.

assembly.group.delete¶

Delete a group. Its members stay in the assembly, ungrouped.

assembly.group.update¶

Rename a group and/or change its membership (add_member_ids / remove_member_ids). Adding a member takes it out of the group it was in.

assembly.ignored_pairs.update¶

Mark interference pairs as known to be fine, or report them again. Pass the key and assembly_id of a pair from check_interference in add_pair_keys / remove_pair_keys. An ignored pair is left out of the check (only counted, and listed under ignored), so use it for a deliberate overlap no mate explains. A key naming a deleted body is harmless and never matches again.

assembly.joint.set_value¶

Move a joint to a position and leave it there. 'angle' is degrees about the joint axis, 'offset' is mm along it, both measured from where the joint was created (so 0 is its build pose). Revolute has an angle, slider an offset, cylindrical both, link an offset that is its absolute length; planar and ball are not drivable this way. Everything mated to the joint follows, and the new placements are saved — use it to pose a mechanism. A target beyond the joint's limits stops at the limit rather than failing. A locked joint still moves when driven here and stays locked at the new value; every other locked joint holds. Read positions back with get_motion_state.

assembly.mate.create¶

Constrain two bodies in an assembly, or give them a joint. Both references name a body (instance_id + target_kind) and a face or edge on it (entity_kind + entity_id from get_topology); target_kind 'origin' means an assembly datum plane/axis instead of a body. Constraints: 'coincident' (faces flush), 'concentric' (axes aligned), 'distance' / 'angle' (need value, mm or degrees), 'fixed' (ground one body, ref_b omitted). Joints leave motion open instead of removing it: 'revolute' (hinge, rotates about the axis), 'slider' (translates along it), 'cylindrical' (both), 'planar' (stays flush, slides and spins), 'ball' (pivots about a point). A joint takes no value; bound it with limit_rot_min_deg / limit_rot_max_deg or limit_trans_min_mm / limit_trans_max_mm. Its position is measured from wherever the parts sit when you create it, so place them at the pose you want to call zero first. Set flip to reverse the direction. A face/edge reference is anchored to its geometry when the mate is created and re-found after later edits, so it keeps following the same face or edge; its stored entity_id is rewritten to the current index. target_kind 'datum' names a datum feature of the part (instance_id = part id, datum_id): entity_kind 'face' for a datum plane, 'edge' for a datum axis, 'vertex' for a datum point (ball, link and distance only). A point-based joint (ball, link) pivots about each reference's anchor point: planar face -> its area centroid, cylindrical/conical face -> that centroid projected onto the axis, spherical face (ball only) -> the sphere centre, circular edge -> its centre, straight edge -> its midpoint, datum axis -> its origin, datum point -> the point itself, origin -> (0,0,0). For an exact pivot use a datum point (a parametric hard point), a spherical face, a circular edge or a datum axis. Returns the mate id. 'link' keeps two anchor points (picked as for 'ball') at a distance that is its offset coordinate, in mm: the absolute length, not measured from creation, so a coil-over with ball ends is one link. Bound it with limit_trans_min_mm / limit_trans_max_mm; stiffness_n_per_mm is stored as metadata only, the solver is kinematic and ignores it. Set locked to hold a revolute, slider, cylindrical or link joint at its current position while other joints are driven.

assembly.mate.delete¶

Delete a mate or joint by id.

assembly.mate.update¶

Edit a mate or joint by mate_id; only provided fields change. Use disabled to switch one off without deleting it, and the limit_* fields to bound a joint's travel. References keep their creation-time anchors (see assembly.mate.create for how they are re-found and where a ball joint pivots). locked true holds a joint at its current position in every solve (driving other joints, sweeps, dragging a body), which is how a ride height or a hinge angle is kept while the rest of a mechanism moves; false frees it again.

assembly_boolean.break¶

Sever a boolean result's link to its sources, freezing the current shape. The part keeps its geometry but stops tracking source edits.

assembly_boolean.create¶

Combine placed parts into a new result part: 'union' merges them, 'cut' subtracts every later source from the first, 'intersect' keeps only the shared volume. Sources are combined where the assembly puts them (world space), not at their model origins, and they are kept rather than consumed — the result is an extra part alongside them, so hide the sources if the result should stand alone. link_mode 'follow_latest' (default) re-captures the result whenever a source changes; 'locked' freezes it. Use check_interference first if you want to know whether the sources actually overlap.

assembly_boolean.refresh¶

Re-capture a boolean result part from its current sources. Only needed for a 'locked' result; 'follow_latest' updates on its own.

assembly_instance.create¶

Place another occurrence of an existing assembly definition (assembly_id) inside parent_assembly_id. One definition placed N times is stored once; placement is parent-frame (translation mm, rotation degrees). Placing a definition inside itself (directly or transitively) is rejected as a conflict.

assembly_instance.delete¶

Remove one occurrence (its definition and other occurrences survive; removing the last occurrence re-promotes the definition to a root).

assembly_instance.move¶

Re-parent one occurrence into new_parent_assembly_id, keeping its id and local placement (so mates inside it survive, unlike delete + re-create). A null target un-nests it to the project root instead: the definition is promoted and the occurrence removed, which is only allowed while this is its sole placement. A move that would make the definition graph cyclic is rejected as a conflict.

assembly_instance.rename¶

Rename a sub-assembly occurrence.

assembly_instance.update_placement¶

Move one sub-assembly occurrence (the whole placed sub-assembly moves as a rigid body); mates reaching through it re-solve.

cam.setup.create¶

Define a CAM manufacturing setup on a part: stock (bbox + margins) plus a list of 2.5D operations. Each operation is {kind, tool_id, face_ids, depth, ...}: kind 'contour' profiles a planar face's outer boundary (side outside/inside/on, climb), 'pocket' area-clears a planar face (its holes become islands; stepover overrides the tool), 'drill' peck-drills selected cylindrical faces (peck, dwell). face_ids are topology ids from get_topology; the target face/hole axis must point along ±Z (top-down 3-axis). depth is the cut depth in mm below the face. Returns the setup id; then call the toolpath generate endpoint to compute paths + G-code.

cam.setup.delete¶

Delete a CAM setup by id.

cam.setup.update¶

Edit a CAM setup (setup_id): name, stock, clearance, or the full operations list. Only provided fields change.

cam.tool.create¶

Create a project-level CAM cutting tool (reusable across parts/operations). Fields: name, type ('flat_endmill'), diameter (mm), feed_rate/plunge_rate (mm/min), spindle_rpm, stepover (mm, pocket pass spacing), stepdown (mm, depth per Z level). Returns the tool id. Reference it from CAM operations.

cam.tool.delete¶

Delete a CAM tool; clears it from any operations referencing it.

cam.tool.update¶

Edit a CAM tool by tool_id; only provided fields change.

commands.batch¶

Run several catalog commands atomically as one revision and one undo step. steps (1-50) run in order, each {type, payload} with the payload that command takes (project_id is added). If a step is rejected, the whole batch is rolled back and the rejection is that step's, its rejection_detail prefixed with the step index and payload.failed_step set. A later step can use an earlier step's result: a string that is exactly "$k.path" (k = an earlier step index from 0, path = dotted keys with [i] list indexes) becomes that value, e.g. "$0.id" or "$1.element_ids[0]". A 10 mm thick disc on part P: [{"type": "sketch.create", "payload": {"part_id": P, "plane": "XY"}}, {"type": "sketch.elements.add", "payload": {"part_id": P, "sketch_id": "$0.id", "elements": [{"geometry_type": "circle", "params": [0, 0, 20]}]}}, {"type": "feature.create", "payload": {"part_id": P, "sketch_id": "$0.id", "distance": 10}}]. Returns {steps: [each step's result]}. A batch cannot contain commands.batch, project.undo, project.redo or project.restore_revision. Each step counts against the MCP command quota.

configuration.activate¶

Activate a configuration by id (its overrides overlay the model on rebuild), or pass configuration_id=null to revert to the base model.

configuration.clear_override¶

Remove one override from a configuration (kind + target_id), reverting that parameter/feature to its base behaviour in this configuration.

configuration.create¶

Create a named configuration (variant) — a set of scoped overrides stored on the project, not a copied model. Returns the new configuration id. Add overrides with configuration.set_override and switch with configuration.activate.

configuration.delete¶

Delete a configuration; if it was active the model reverts to base.

configuration.set_override¶

Set one scoped override on a configuration. kind='parameter' with expression overrides a parameter (target_id = parameter id); kind='suppression' with suppressed=true/false force-suppresses or force-enables a feature (target_id = feature id). This is how a variant differs from the base.

configuration.update¶

Rename a configuration or change its description (only provided fields change).

feature.create¶

Extrude a sketch profile into a solid (boolean_mode new/add/cut/intersect). When the sketch has several closed regions, pick them with region_anchors (an [x,y] point inside each wanted region; preferred — get them from get_sketch_regions) or wire_indices; omit to extrude every region. For a cut, set through_all=true to cut clean through the whole part instead of a fixed distance. thin_thickness (mm, with thin_thickness_expression) makes a thin-wall extrude: every loop of the closed profile, holes included, becomes a wall that thick, grown into the profile ('inside', default), away from it ('outside', outer corners rounded) or half each way ('symmetric') per thin_side. One circle plus thin_thickness is a tube. Open chains are Rib's job. Returns the new feature id.

feature.create.chamfer¶

Bevel one or more edges by a distance (and optional angle, default 45deg). edge_ids are topology ids from get_topology.

feature.create.circular_pattern¶

Repeat the part geometry around an axis. count copies spread over total_angle (default 360deg). The axis defaults to Z through the origin (axis_origin=(0,0,0), axis_dir=(0,0,1)); set axis_origin/axis_dir or datum_axis_id for any other axis.

feature.create.datum_axis¶

Create a reference axis (no solid) by mode: 'two_point' (two vertex or datum_point refs, e.g. a kingpin through two hard points), 'face_axis', 'plane_intersection', or 'reference_line'. refs lists the referenced entities.

feature.create.datum_plane¶

Create a reference plane (no solid) by mode: 'offset' from a base plane (by offset mm), 'midplane' between two parallel planes, 'three_point' through three points (vertex refs or datum_point refs), 'angle' rotating a base plane by angle degrees around an axis, 'perpendicular' to an axis or edge at its origin/midpoint, or 'explicit': the XY plane rotated by rx, ry, rz degrees (about the part X, Y, Z axes, applied X then Y then Z, like a placement) and moved to origin_x/origin_y/origin_z, or to a datum point given as the single ref. Every offset, angle, origin and rotation value takes a *_expression sibling, so a kingpin or caster plane can follow parameters. refs lists the referenced entities (one per mode's arity); flip negates the resulting normal. Mirror and split define their plane the same way, and a sketch sits on it with plane='datum'.

feature.create.datum_point¶

Create a reference point (no solid) at x, y, z in the part frame (mm). Model hard points (pivots, pickup points, kingpin ends) as datum points whose x_expression/y_expression/z_expression read project parameters, then build on them: a two_point datum axis or a three_point/explicit datum plane through them, a primitive between them, or a ball joint / distance mate pivoting exactly on one (mate ref target_kind 'datum', entity_kind 'vertex'). Changing the parameter moves everything built on the point. Returns the feature id and the resolved point.

feature.create.draft¶

Taper faces by a constant draft angle about a neutral plane (for mold release). face_ids and neutral_plane_face_id are topology ids from get_topology; neutral_plane_face_id is a planar face whose outward normal is the pull direction; angle is in degrees (0–90). Set reverse to flip the taper direction.

feature.create.fillet¶

Round one or more edges with a constant radius. edge_ids are topology ids of the current part shape (from get_topology). Returns the new feature id.

feature.create.helix¶

Sweep a sketch profile helically around an axis (springs, coils, custom threads with boolean_mode 'cut'). Profile region and axis are picked as for revolve; sketch the profile on a plane containing the axis, beside it. Give two of pitch, turns and height (height = pitch * turns, all for the active coils): size_mode names the two, and without it the two you give pick it. The third is derived, and a value given for it must agree. handedness right/left, reverse advances against the axis, taper_angle (deg) makes a conical helix. Pitch must exceed the profile's axial size d. closed_ends adds one dead turn per end at a pitch of d (0.1 % more, so the coils never fuse); ground_ends trims both ends flat. Overall length along the axis, with h = height: plain h + d, closed h + 3d, ground h, closed and ground h + 2d. A ground spring starts flat level with the profile's centre (measured along the axis) and runs in the advance direction; without grinding the wire reaches half the profile (d/2 for a round wire) beyond each end.

feature.create.hole¶

Drill a parametric hole into a single planar face. face_ids is the planar face id from get_topology; position is the [x, y] face-plane offset (mm) from the face centre. hole_type is 'simple', 'counterbore', or 'countersink'; depth_mode is 'through_all' or 'blind' (then set depth). Size from a standard table (sizing_mode='standard', standard_id 'iso_metric'/'unc', designation e.g. 'M6', fit 'close'/'normal'/'loose'; tapped=true sizes the bore to the tap-drill diameter) or a custom diameter (sizing_mode='custom').

feature.create.linear_pattern¶

Repeat the part geometry along one or two linear directions. Each direction has a count (>=2) and a non-zero spacing (negative reverses the direction); boolean_mode 'add' fuses the copies, 'new' keeps them as separate selectable bodies, and 'cut'/'intersect' subtract them from / keep their overlap with the source.

feature.create.loft¶

Loft a solid through two or more sketch profiles (ruled or smooth) — the tool for shapes that change cross-section along their length (e.g. a twisted blade). sketch_ids lists the profiles in order, usually on offset/datum planes at different heights. Pick each profile's region with region_anchors ([x,y] inside each, aligned 1:1 with sketch_ids; from get_sketch_regions) or wire_indices.

feature.create.mirror¶

Mirror the part geometry across a plane. The plane is defined like a datum plane (mode + refs, see FEATURE_CREATE_DATUM_PLANE). boolean_mode 'new' (default) keeps the copy as a separate body, 'add' fuses it, 'cut' subtracts it, 'intersect' keeps the overlap.

feature.create.primitive¶

Add a solid primitive without a sketch: kind 'cylinder' or 'tube' along the segment start -> end, 'torus' centred on start with its axis along end - start, or 'sphere' centred on start (end unused). Each point is a datum point (start_datum_id / end_datum_id, which win) or start_x/y/z, end_x/y/z in the part frame, every coordinate with a _expression sibling. Sizes: radius (the major radius of a torus), wall_thickness for a tube (bore = radius - wall_thickness), minor_radius for a torus, each with a _expression. boolean_mode new/add/cut/intersect as for extrude. The way to model wishbone legs, pins, bushings, eyes and rings: put the hard points in datum points driven by parameters and run tubes between them, and they follow every parameter change. Returns the new feature id.

feature.create.revolve¶

Revolve a sketch profile around an axis (sketch-plane 'x'/'y', an explicit axis_origin/axis_dir, or a datum_axis_id). angle defaults to 360deg for a full revolution. Select the profile region with region_anchor ([x,y] inside it, from get_sketch_regions) or wire_index. The cross-section must be closed and not cross the axis.

feature.create.rib¶

Thicken a sketch profile into a thin support wall (rib/web) unioned with the part. sketch_id references the rib sketch; an open chain is offset by thickness (mm), a closed region (wire_indices/region_anchors) is used directly; side ('symmetric'|'one'|'other') sets the growth direction along the sketch-plane normal. Requires existing geometry.

feature.create.shell¶

Hollow the part to a uniform wall thickness, removing the given faces. face_ids are topology ids from get_topology; thickness > 0 is inward.

feature.create.split¶

Split a solid by a plane into separate bodies. The plane is defined like a datum plane (mode + refs, see FEATURE_CREATE_DATUM_PLANE). source_solid_id picks which solid to split (None = whole shape); keep_solid_ids (indices into the ordered pieces, -normal side first, so flip reverses them) keeps a subset, None keeps all.

feature.create.surface_pattern¶

Apply a mathematically-defined relief pattern to a single face. face_ids is the face id from get_topology; function is a displacement expression of u,v (normalised [0,1]) and x,y,z (mm), scaled by amplitude (mm) along the face normal. mode 'smooth' fits a B-spline surface (waves); 'faceted' builds planar facets (low-poly / grips). resolution sets the grid/facet density.

feature.create.sweep¶

Sweep a profile sketch along a path sketch to create a solid.

feature.create.thread¶

Cut a real helical thread into a single cylindrical face. face_ids is the cylindrical face id from get_topology; pitch is the thread pitch in mm.

feature.delete¶

Delete a feature. Dependents are kept: one that can no longer compute is flagged unresolved_reference or failed (see get_diagnostics). Returns deleted_feature_ids.

feature.reorder¶

Move a feature to a different position in the part history: it is placed after insert_after_history_id (a feature, sketch or mate id; null moves it to the very start). Reordering is organisational only, so the server trial-rebuilds the new order and refuses anything that would change the resulting model (409) or that breaks the history rules, e.g. a fillet before the solid it rounds (422). Requires the rollback bar to be cleared. Returns the part's feature timeline.

feature.set_detail¶

Pin how a feature is classified for the simplified display representation of large assemblies. detail=true always omits it, detail=false always keeps it, detail=null reverts to the automatic rule (threads, text emboss and surface patterns are always detail; fillets/chamfers at or below the project simplify threshold are). Display-only: modeled geometry, exports, mass properties and simulation are unaffected.

feature.suppress¶

Suppress (suppressed=true) or un-suppress a feature, excluding it from the shape build. Set include_downstream=true to also suppress later features broken by this one — a one-click clear of a broken cascade. Returns the part's feature timeline with rebuild statuses.

feature.update¶

Edit an existing extrude feature (feature_id) — change distance, boolean_mode, through_all, thin wall, etc. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.chamfer¶

Edit an existing chamfer (feature_id): change distance/angle/edges. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.circular_pattern¶

Edit an existing circular pattern (feature_id): change axis/count/angle. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.datum_axis¶

Edit an existing datum axis (feature_id): change its definition. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.datum_plane¶

Edit an existing datum plane (feature_id): change its definition. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.datum_point¶

Edit an existing datum point (feature_id): change its coordinates or their expressions. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.draft¶

Edit an existing draft (feature_id): change angle/faces/neutral plane/reverse. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.fillet¶

Edit an existing fillet (feature_id): change radius/edges. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.helix¶

Edit an existing helix (feature_id): change axis/pitch/turns/ends/etc. Sizes work as for feature.create.helix: the size the size_mode derives follows the other two, and two sizes without a size_mode pick the mode. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.hole¶

Edit an existing hole (feature_id): change size/type/depth/position/tapped/face. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.linear_pattern¶

Edit an existing linear pattern (feature_id): change direction/count/spacing (non-zero, negative reverses the direction). Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.loft¶

Edit an existing loft (feature_id): change profiles/ruled/solid. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.mirror¶

Edit an existing mirror (feature_id): change the plane definition (mode + refs) or boolean_mode. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.primitive¶

Edit an existing primitive (feature_id): change kind, points, sizes or boolean_mode. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.revolve¶

Edit an existing revolve (feature_id): change axis/angle/etc. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.rib¶

Edit an existing rib (feature_id): change sketch/thickness/side/region. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.shell¶

Edit an existing shell (feature_id): change thickness/removed faces. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.split¶

Edit an existing split (feature_id): change the plane definition (mode + refs), source_solid_id or keep_solid_ids. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.surface_pattern¶

Edit an existing surface pattern (feature_id): change function/amplitude/mode/resolution/face. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.sweep¶

Edit an existing sweep (feature_id): change profile/path sketches. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

feature.update.thread¶

Edit an existing thread (feature_id): change pitch/handedness/etc. Send only the fields to change; the others keep their stored values. A number replaces its field's expression, null clears a nullable field, and a region selection left out stays as it is. A datum reference or start_face keeps driving the values it overrides until set to null.

flow.create¶

Define a flow (CFD) study on a part: air or water moving around it, or the part spinning in it. mode 'tunnel' (default) blows a free stream at speed m/s along inlet_axis ('+x'..'-z') and reports the force and the moment on the body (10 m/s is a reasonable default in air, 1 m/s in water — water is a thousand times denser, so air's speeds pose a Reynolds number this method has no business answering); mode 'rotation' spins the part at rpm about axis_origin/axis_dir and reports volumetric flow rate and torque. Any body may rotate, not only a bladed one; the axis is required in rotation mode, and a study created on a part that has a circular pattern is seeded from it. An axis on a tunnel study is optional and means something different: the result then also reports axis_torque_n_mm, how hard the stream twists the static part about it. fluid picks the working fluid {preset: 'air'|'water'|'custom', density kg/m3, dynamic_viscosity Pa*s}. resolution is a runtime budget, 'draft' | 'standard' | 'fine' (roughly 1, 5 and 10 minutes); the lattice cell size is derived from it, so leave cell_size unset unless reproducing an exact run. domain is the flow volume {min, max} in mm and is auto-sized around the part when unset: a tunnel about two and a half body-lengths long with the part forward of centre, a rotating body in a duct at 1.2x the tip radius. Returns the study id; then call run_flow_study to solve it. This is a design-stage trend tool on a staircase lattice, not a certified answer: read every number it returns as an order of magnitude with a reliable direction, and a rotating body's torque and shaft power especially so.

flow.delete¶

Delete a flow study by id.

flow.update¶

Edit a flow study (study_id): change name, mode, fluid, inlet_axis, speed, flow_throughs, rpm, revolutions, axis_origin/axis_dir, domain, resolution, cell_size, slice or streamline_seeds. Only provided fields change; send domain or cell_size as null to put them back on auto. Switching mode to 'rotation' does not seed an axis — only creating a study does — so set axis_origin/axis_dir if the study has none. Changing a tunnel study's axis does not invalidate a finished solve: the torque about it is projected from the result when it is read.

import.heal¶

Heal an imported part's geometry (feature_id of its import feature): sew open shells, fix invalid wires/solids, and merge coplanar faces. heal=true applies the repair, heal=false reverts to the raw import. Returns the rebuild status, diagnostics, and a before/after summary. Useful before referencing or remodeling imported geometry.

import.set_units¶

Correct an imported part's unit scale (feature_id of its import feature). units_mm is millimetres per source unit (1=mm, 10=cm, 1000=m, 25.4=inch, 304.8=ft); use it when an STL has no units or a STEP/IGES was tagged with the wrong unit. Rescales without re-import.

material.create¶

Create a custom project material. Pass derive_from='builtin:' to copy a built-in (from the materials library) as an editable starting point, or supply appearance/mechanical/printing directly. The optional printing group makes the material printable and supplies the FDM filament settings: family ('pla'/'petg'/'tpu'), nozzle_temp & bed_temp (+ first_layer_* variants, °C), fan/cooling and flow_ratio/diameter/max_volumetric_speed. Returns the material.

material.delete¶

Delete a custom material; clears it from any parts referencing it.

material.update¶

Edit a custom material (name/category/appearance/mechanical/printing). Only provided fields change; printing=null makes a material unprintable. Built-in materials are read-only — derive a copy first.

parameter.create¶

Create a named project parameter from an expression (e.g. 'width' = '40'). Parameters can be referenced in dimension expressions.

parameter.delete¶

Delete a parameter by id.

parameter.update¶

Rename or re-express an existing parameter.

part.assign_material¶

Assign a material (built-in or custom id) to a part, or clear it with material_id=null. Drives appearance, mass, 3MF export colour, and the filament settings a slice setup prints the part with. For a part made of several solids, solid_id (a 0-based solid ordinal, as reported by get_topology) assigns that solid alone, overriding the part's own material; giving two solids different printable materials is what makes the part print multi-material.

part.create¶

Create a new (empty) part to hold sketches and features. Returns the new part id. The first step when modeling from scratch.

part.delete¶

Delete a part (and all its sketches/features).

part.duplicate¶

Deep-copy a part (all sketches, features, bodies) into an independent, editable part. Returns the new part id.

part.move¶

Move a part into target_assembly_id at index (its position in that assembly's part list, counted before the move; appends when omitted). Naming the assembly the part is already in just reorders it there. Across assemblies the part keeps its local placement, and every mate against it goes stale and is pruned project-wide — the count comes back as pruned_mates.

part.rename¶

Rename a part by id.

part.update_rollback¶

Move the part's rollback bar: feature_id builds only up to and including that feature (later ones are rolled back); null clears the bar and rebuilds everything.

project.redo¶

Re-apply the last change undone by project.undo.

project.restore_revision¶

Make an earlier revision the working state again, e.g. to back out many commands at once. list_revisions shows the restorable revisions. The restore is a new revision and one undo step, so project.undo returns to where you were, and later revisions stay in the history. An unknown or pruned revision is rejected as not_found.

project.set_simplify_threshold¶

Set the project's simplify threshold in mm (default 2). Fillets with radius and chamfers with distance at or below it are omitted from the simplified display representation. Display-only: it never changes the modeled geometry.

project.undo¶

Revert the most recent change (undo the last mutation). Use this to back out a mistake instead of deleting and rebuilding geometry.

simulation.create¶

Define a stress study on a part. kind 'static' (default) is the linear-static analysis described below; kind 'warpage' instead predicts the residual stress and distortion the part is left with after printing — it needs print_setup_id and ignores fixtures, loads and gravity, being driven by the part's own contraction while it stands on the bed. For a static study: fixed_face_ids are faces to fully clamp and fixed_edge_ids are edges to clamp the same way (use a face where one exists — an edge clamp is a stress singularity, so the peak stress and factor of safety at it are mesh-dependent); loads is a list of {kind, target_kind, face_id|edge_id, magnitude, direction, flip}: target_kind 'face' (default) loads a face by face_id, 'edge' applies a line load to an edge by edge_id (force only, needs an explicit direction). kind 'force' applies magnitude N along direction (a 3-vector; defaults to a face's inward normal), kind 'pressure' applies magnitude MPa along the inward face normal. Set direction_mode='radial' (force only, on a cylindrical face or circular edge) to push magnitude N radially outward from the geometry's axis, or 'tangential' to apply it circumferentially about the axis (a torque — for gears/shaft torsion); axis_origin/axis_dir override the auto-detected axis. Set flip=true to reverse the direction (force/radial/tangential) or pull outward in tension (pressure). Set gravity to a 3-vector acceleration in m/s² (e.g. (0, 0, -9.81)) to add self-weight over the whole part; omit for none. All face_id/edge_id values are topology ids from get_topology. The part needs a material with Young's modulus, Poisson ratio and yield strength (assign one with part.assign_material; derive a built-in metal/plastic if needed). Returns the study id. Then call run_stress_study to solve and read max von Mises stress, displacement and factor of safety — if the factor of safety is too low, thicken the geometry or pick a stronger material and re-run to close the loop.

simulation.delete¶

Delete a stress study by id.

simulation.update¶

Edit a stress study (study_id): change name, kind ('static'/'warpage'), fixed_face_ids, fixed_edge_ids, loads, gravity (self-weight m/s² 3-vector, or null to disable), print_setup_id (null to solve as solid material) or max_size (target mesh element size in mm). Only provided fields change.

sketch.arc3¶

Create a single arc through three points p1 (start), p2 (on the arc), p3 (end), each [x,y]. Use this instead of authoring raw arc [cx,cy,r,start,end] params, which are error-prone to compute.

sketch.chamfer¶

Bevel a sketch corner with the given setback distance. Same selection modes as sketch.fillet.

sketch.constraint.add¶

Add geometric/dimensional constraints to a sketch and run the solver. Use to make a sketch fully constrained. Supported operand combinations: tangent — line/axis with circle/arc, or two curves; equal — two lines or two curves; parallel/perpendicular/collinear/angle — lines and origin axes; concentric — two curves; radius/diameter — one circle or arc; midpoint — a point then the line it bisects; point_on_line/point_on_circle/point_on_arc — a point then the curve; distance — two points, one line's length, or a line with another line/axis. Point indices: line 0-1, arc 0=centre 1-2=endpoints, circle/point 0. distance/distance_x/distance_y/radius/diameter/angle require a value (angle in radians); symmetric requires axis 'x' or 'y'. Other combinations are rejected. Returns constraint_ids, one per requested constraint in order: the id that now carries it, or null if it was dropped. Dimensioning a size that already has a dimension (a line's length, a radius) edits that dimension in place, and a duplicate relationship is matched; both keep the existing id. A lone dimension whose value one driving dimension already determines moves the value onto that dimension and is kept as a reference; when several do, the 409 names them.

sketch.constraint.delete¶

Remove a constraint (constraint_id) from a sketch and re-solve.

sketch.constraint.toggle¶

Edit an existing constraint in place: change a dimension's value or expression, make it driving or reference, or disable it. constraint_id comes from get_sketch or from the constraint_ids sketch.constraint.add returns. Send only the fields to change: value (mm, angles in radians), expression, driving, disabled, name, or constraint_type to re-state the same operands as another type (e.g. point_on_arc -> point_on_circle, keeping the id). The sketch is re-solved.

sketch.copy¶

Deep-copy a sketch (elements + constraints) to target_part_id (may be the same part). Mirrors, offsets and patterns are copied live and keep following the copied sources; projected geometry stays linked only within the same part.

sketch.create¶

Create a sketch on an origin plane (XY/XZ/YZ) or off-origin. For a raised or pitched sketch set offset (mm along the plane normal) and/or tilt_angle (deg about the plane X axis) — useful for stacking loft profiles or angling a feature. Or pass plane_def {origin,normal,x_dir} (stored as plane 'face'), face_ref {part_id,face_id} to sketch on a face, edge_ref, or plane 'datum' with datum_ref {datum_id} to sketch on a datum plane. Returns the new sketch id.

sketch.delete¶

Delete a sketch; cascade-deletes features that consume it.

sketch.element.delete¶

Delete one or more sketch elements (element_ids) and any constraints referencing them, then re-solve.

sketch.element.toggle_construction¶

Set the construction flag on sketch elements (element_ids). Construction geometry is auxiliary and not part of profiles.

sketch.element.trim¶

Trim a sketch element at its intersections; the segment nearest (click_x, click_y) is removed, remaining segments kept.

sketch.elements.add¶

Add geometry elements (line/circle/arc/point) to a sketch. Each element has a geometry_type and a flat params list in sketch-plane coordinates (line [x1,y1,x2,y2]; circle [cx,cy,r]; arc [cx,cy,r,start_deg,end_deg]; point [x,y]). Each line/circle/arc is AUTOMATICALLY given a driving dimension (length/radius) and touching endpoints are AUTOMATICALLY welded with coincident constraints, so a connected chain closes without extra work — do not re-add those dimensions or coincidences. For a rectangle or an arc through three points, prefer sketch.rectangle / sketch.arc3.

sketch.elements.offset¶

Create associative parallel offset copies of element_ids at the given distance (positive = outward; negative = inward).

sketch.fillet¶

Round a sketch corner with an arc of the given radius. Provide element_id_a + element_id_b for one corner, or element_ids (>=2) for all shared corners.

sketch.intersect_geometry¶

Intersect the part body with the sketch plane, adding the cross-section outline as static (non-associative) sketch geometry. Set construction=true to add it as construction geometry. Section curves the sketch cannot represent (an ellipse from an oblique cylinder, a spline) are returned in 'skipped'.

sketch.mirror¶

Create associative mirror copies of element_ids reflected across the straight line element axis_element_id. Copies follow their sources and the axis on every solve.

sketch.pattern.delete¶

Delete a sketch pattern (pattern_id). keep_elements=true leaves the copies as independent geometry; false removes them.

sketch.polygon¶

Create a regular polygon: center [x,y], radius, sides (>=3), optional rotation (deg). inscribed=true (default) puts the vertices on the radius (across-corners); inscribed=false puts the edge midpoints on it (across-flats, e.g. a hex nut). Emits a welded closed loop with equal sides plus a construction circumcircle — constrain its centre (e.g. coincident with the origin) to locate the polygon. radius_expression drives the size from a parameter, measured the same way radius is (so pass the across-flats expression with inscribed=false); lock_rotation pins the orientation, which leaves the centre as the only free degree of freedom; construction marks the sides as construction geometry.

sketch.project_geometry¶

Project a source body's edges/faces onto the sketch plane as associative geometry that re-resolves from the live body on every rebuild (like 'Convert Entities' / 'Project'). Give edge_ids and/or a face_id (a face is expanded to its boundary edges); source_part_id defaults to the sketch's own part. Projected elements participate in profiles unless construction=true. Only lines and circles/arcs whose plane is parallel to the sketch are projected; oblique/unsupported edges are returned in 'skipped'.

sketch.rectangle¶

Create a rectangle from two opposite corners p1 and p2 ([x,y] each), optionally tilted in-plane by rotation degrees about its centre. Emits four welded, closed sides — a ready-to-use closed profile in one call. A thin rotated rectangle is the canonical pitched blade/vane section; vary rotation between lofted sections to twist a blade.

sketch.slot¶

Create a rounded linear slot between two centre points center_a / center_b ([x,y]) with end radius — two parallel sides capped by semicircles. A ready-to-use closed profile (e.g. a fastener slot).

sketch.update_plane¶

Re-define an existing sketch's plane (origin plane, plane_def, offset, tilt, face/edge/datum ref). Only provided fields change; dependent features rebuild. Normalised like sketch.create: a plane_def on an origin plane becomes plane 'face', a bare face_ref derives the plane from that face.

slicer.printer.create¶

Create a project-level 3D printer (reusable across parts/setups). machine_preset ('generic' or 'bambu_x1c') picks a builtin engine preset; the physical facts bed_x/bed_y/bed_z (mm), nozzle_diameter (mm) and gcode_flavor ('marlin2' or 'bambu') default from it when omitted, and can be overridden. The filament is not part of the printer: it follows the sliced part's material. Returns the printer id; reference it from a slice setup.

slicer.printer.delete¶

Delete a printer; clears it from any slice setups referencing it.

slicer.printer.update¶

Edit a printer by printer_id; only provided fields change. Changing machine_preset re-materializes bed/nozzle/flavor from the new preset unless those are also given explicitly.

slicer.setup.create¶

Define an FDM slicing setup on a part (part_id) or a whole assembly (assembly_id, printed as one plate with placements applied): a printer_id plus process settings. process_preset ('draft' 0.28mm / 'standard' 0.20mm / 'fine' 0.12mm) is the base; every other field overrides one preset value and may be omitted to use the preset (null = preset value). Overridable: layer_height (mm), wall_count, top_layers, bottom_layers, infill_density (0..1 fraction), infill_pattern (rectilinear/grid/triangles/cubic/honeycomb/gyroid), seam (nearest/aligned/back), print_speed & first_layer_speed (mm/s), skirt_loops, brim_width (mm, 0=off). Supports: support_enabled (default off), support_type (normal grid / tree branching), support_angle (overhang threshold degrees from horizontal). Filament settings (temperatures, cooling, flow) are not set here: they come from the part's assigned material — see material.create / part.assign_material. material_id names a printable stand-in used only when the part's own material isn't printable (e.g. prototyping a steel part in PLA). Returns the setup id; then call the slice generate endpoint (or slice_part) to compute layers + G-code.