solidworks_mcp.adapters.mock_adapter

solidworks_mcp.adapters.mock_adapter

Mock SolidWorks adapter for testing and development.

This adapter simulates SolidWorks operations for testing on non-Windows platforms or when SolidWorks is not available.

Attributes

RELATION_NAME_MAP module-attribute

RELATION_NAME_MAP: dict[str, int] = {'horizontal': 4, 'vertical': 5, 'tangent': 6, 'parallel': 7, 'perpendicular': 8, 'coincident': 9, 'concentric': 10, 'symmetric': 11, 'equal': 14, 'fix': 17, 'collinear': 27}

_AXIS_PLANE_PAIRS module-attribute

_AXIS_PLANE_PAIRS: dict[str, tuple[str, str]] = {'x': ('Top Plane', 'Front Plane'), 'y': ('Front Plane', 'Right Plane'), 'z': ('Top Plane', 'Right Plane')}

_DEFAULT_ASSEMBLY_COMPONENTS module-attribute

_DEFAULT_ASSEMBLY_COMPONENTS: dict[str, dict[str, Any]] = {'PartA': {'type': 'Part', 'path': 'Mock://PartA.sldprt', 'features': [{'name': 'Boss-Extrude1', 'type': 'Extrusion', 'suppressed': False}, {'name': 'Fillet1', 'type': 'Fillet', 'suppressed': False}]}, 'PartB': {'type': 'Part', 'path': 'Mock://PartB.sldprt', 'features': [{'name': 'Cut-Extrude1', 'type': 'Cut', 'suppressed': False}]}, 'SubAssembly1': {'type': 'Assembly', 'path': 'Mock://SubAssembly1.sldasm', 'features': [{'name': 'Mate1', 'type': 'Mate', 'suppressed': False}], 'components': {'PartC': {'type': 'Part', 'path': 'Mock://PartC.sldprt', 'features': [{'name': 'Boss-Extrude1', 'type': 'Extrusion', 'suppressed': False}]}}}}

_MOCK_NAMED_VIEWS module-attribute

_MOCK_NAMED_VIEWS: frozenset[str] = frozenset({'front', 'back', 'left', 'right', 'top', 'bottom', 'isometric', 'iso', 'trimetric', 'dimetric', 'current'})

Classes

AdapterHealth

Bases: BaseModel

Health status information for adapters.

Attributes:

Name	Type	Description
average_response_time	float	The average response time value.
connection_status	str	The connection status value.
error_count	int	The error count value.
healthy	bool	The healthy value.
last_check	datetime	The last check value.
metrics	dict[str, Any] | None	The metrics value.
success_count	int	The success count value.

Methods:

__contains__

__contains__(key: str) -> bool

Build internal contains.

Parameters:

Name	Type	Description	Default
key	str	The key value.	required

Returns:

Name	Type	Description
bool	bool	True if contains, otherwise False.

Source code in src/solidworks_mcp/adapters/base.py

def __contains__(self, key: str) -> bool:
    """Build internal contains.

    Args:
        key (str): The key value.

    Returns:
        bool: True if contains, otherwise False.
    """
    legacy_keys = {"status", "connected", "adapter_type", "version", "uptime"}
    if key in legacy_keys:
        return True
    return key in self.model_dump()

__getitem__

__getitem__(key: str) -> Any

Build internal getitem.

Parameters:

Name	Type	Description	Default
key	str	The key value.	required

Returns:

Name	Type	Description
Any	Any	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

def __getitem__(self, key: str) -> Any:
    """Build internal getitem.

    Args:
        key (str): The key value.

    Returns:
        Any: The result produced by the operation.
    """
    if key == "status":
        return "healthy" if self.healthy else "unhealthy"
    if key == "connected":
        return self.connection_status == "connected"
    if key == "adapter_type":
        return (self.metrics or {}).get("adapter_type")
    if key == "version":
        return (self.metrics or {}).get("version", "mock-1.0")
    if key == "uptime":
        return (self.metrics or {}).get("uptime", 0.0)
    return self.model_dump().get(key)

AdapterResult dataclass

AdapterResult(status: AdapterResultStatus, data: T | None = None, error: str | None = None, execution_time: float | None = None, metadata: dict[str, Any] | None = None)

Result wrapper for adapter operations.

Attributes:

Name	Type	Description
data	T | None	The data value.
error	str | None	The error value.
execution_time	float | None	The execution time value.
metadata	dict[str, Any] | None	The metadata value.
status	AdapterResultStatus	The status value.

Attributes

is_error property

is_error: bool

Check if operation had an error.

Returns:

Name	Type	Description
bool	bool	True if error, otherwise False.

is_success property

is_success: bool

Check if operation was successful.

Returns:

Name	Type	Description
bool	bool	True if success, otherwise False.

AdapterResultStatus

Bases: StrEnum

Result status for adapter operations.

Attributes:

Name	Type	Description
ERROR	Any	The error value.
SUCCESS	Any	The success value.
TIMEOUT	Any	The timeout value.
WARNING	Any	The warning value.

ExtrusionParameters

Bases: BaseModel

Parameters for extrusion operations.

Attributes:

Name	Type	Description
auto_select	bool	The auto select value.
both_directions	bool	The both directions value.
depth	float	The depth value.
draft_angle	float	The draft angle value.
end_condition	str	The end condition value.
feature_scope	bool	The feature scope value.
merge_result	bool	The merge result value.
reverse_direction	bool	The reverse direction value.
sketch_name	str | None	Explicit sketch to operate on. When set, callers (e.g. create_cut_extrude) must select exactly this sketch and fail with a clear error if it doesn't exist rather than silently falling back to some other sketch.
thin_feature	bool	The thin feature value.
thin_thickness	float | None	The thin thickness value.
thin_side	str	Which side of the sketch a thin wall grows on: one_side, other_side or mid_plane.
up_to_surface	str | None	The up to surface value.

LoftParameters

Bases: BaseModel

Parameters for loft operations.

Attributes:

Name	Type	Description
end_tangent	str | None	The end tangent value.
guide_curves	list[str] | None	The guide curves value.
merge_result	bool	The merge result value.
profiles	list[str]	The profiles value.
start_tangent	str | None	The start tangent value.

MassProperties

Bases: BaseModel

Mass properties information.

Attributes:

Name	Type	Description
center_of_mass	list[float]	The center of mass value.
mass	float	The mass value.
moments_of_inertia	dict[str, float]	The moments of inertia value.
principal_axes	dict[str, list[float]] | None	The principal axes value.
surface_area	float	The surface area value.
volume	float	The volume value.

MockSolidWorksAdapter

MockSolidWorksAdapter(config: object | None = None)

Bases: SolidWorksAdapter

Mock adapter that simulates SolidWorks operations.

Parameters:

Name	Type	Description	Default
config	object | None	Configuration values for the operation. Defaults to None.	None

Attributes:

Name	Type	Description
_connected	Any	The connected value.
_delays	Any	The delays value.
_is_connected_proxy	Any	The is connected proxy value.
_operation_count	Any	The operation count value.
_simulate_errors	Any	The simulate errors value.

Initialize the mock solid works adapter.

Parameters:

Name	Type	Description	Default
config	object | None	Configuration values for the operation. Defaults to None.	None

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __init__(self, config: object | None = None) -> None:
    """Initialize the mock solid works adapter.

    Args:
        config (object | None): Configuration values for the operation. Defaults to None.

    Returns:
        None: None.
    """
    super().__init__(config)
    cfg: dict[str, Any] = dict(self.config_dict)
    self._connected = False
    self._current_model = None
    self._models: dict[str, SolidWorksModel] = {}
    self._features: dict[str, SolidWorksFeature] = {}
    # Names suppressed via suppress_feature. Kept beside _features rather
    # than on SolidWorksFeature, which has no suppression field.
    self._suppressed_features: set[str] = set()
    # Component tree for an Assembly-type current model, keyed by
    # component name. See ``_flatten_assembly_components`` for shape.
    # Empty means "use the canned default fixture" (see list_features).
    self._assembly_components: dict[str, dict[str, Any]] = {}
    self._sketches: dict[str, str] = {}
    self._current_sketch: str | None = None
    # Names currently "selected" via select_feature / select_face_edges,
    # so append and selection_count behave like the real selection set.
    self._selection: list[str] = []
    # Test hook: RawRebuildIssue objects rebuild_model should report, so
    # the error/warning paths can be exercised without real geometry.
    self.injected_rebuild_issues: list[Any] = []
    # Tracks IDs returned by add_line/add_arc/add_circle/add_centerline/
    # add_rectangle/add_spline so add_sketch_constraint can validate
    # entity1/entity2 the same way the real adapter validates against
    # its sketch-entity registry.
    self._sketch_entity_ids: set[str] = set()
    self._dimensions: dict[str, float] = {}
    # Assembly components inserted via insert_component, keyed by
    # insertion order. See insert_component/list_components/add_mate.
    self._components: list[str] = []
    # Mates added via add_mate, in order, so the geometry summary can
    # report a mate count without real geometry.
    self._mates: list[dict[str, Any]] = []
    self._component_states: dict[str, dict[str, bool]] = {}
    # Drawing views placed via create_drawing_view / add_drawing_view /
    # create_technical_drawing, in sheet order. See list_drawing_views.
    self._drawing_views: list[str] = []
    # Reference planes created via create_reference_plane, in creation
    # order, used to invent sequential "PlaneN" names. Shared feature
    # tree counter with create_axis mirrors the live adapter's
    # features_before/features_after pair (see _feature_count in
    # solidworks/features.py).
    self._reference_planes: list[str] = []
    # Axes created via create_axis, in creation order, used to invent
    # sequential "AxisN" names the same way self._reference_planes
    # invents "PlaneN" names, and to validate the axis name passed to
    # pattern_circular the same way known_sources validates mirror
    # sources.
    self._axes: list[str] = []
    # Reference points created via create_reference_point, in creation
    # order, invented "PointN" names on the same pattern as _axes.
    self._reference_points: list[str] = []
    # Centre-mark count per drawing-view name, grown by auto_center_marks.
    self._center_marks: dict[str, int] = {}
    self._feature_tree_count = 0
    # Volume tracked for mirror_feature, in mm^3. Seeded at the
    # live-measured 1819569.1 mm^3 wing volume from
    # _mirror_feature_impl in solidworks/features.py, then doubled on
    # each successful mirror so volume_before/volume_after/volume_ratio
    # stay self-consistent without a real geometry engine.
    self._mirror_volume: float = 1819569.1
    # Volume tracked for pattern_circular, in mm^3. Seeded at the
    # live-measured 48431.5 mm^3 hub+blade volume from
    # _pattern_circular_impl in solidworks/features.py, then grown by
    # _PATTERN_BLADE_VOLUME per extra instance on each successful
    # pattern so volume_before/volume_after/volume_ratio stay
    # self-consistent without a real geometry engine.
    self._pattern_volume: float = 48431.5
    self._operation_count = 0

    # Configurable simulation delays (in seconds)
    self._delays = {
        "connect": cfg.get("mock_connect_delay", 0.1),
        "model_operation": cfg.get("mock_model_delay", 0.02),
        "feature_operation": cfg.get("mock_feature_delay", 0.03) if cfg else 0.03,
        "sketch_operation": cfg.get("mock_sketch_delay", 0.1),
    }
    self._is_connected_proxy = _BoolCallable(lambda: self._connected)
    self._simulate_errors = bool(cfg.get("simulate_errors", False))

Methods:

__getattribute__

__getattribute__(name: str) -> Any

Build internal getattribute.

Parameters:

Name	Type	Description	Default
name	str	The name value.	required

Returns:

Name	Type	Description
Any	Any	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __getattribute__(self, name: str) -> Any:
    """Build internal getattribute.

    Args:
        name (str): The name value.

    Returns:
        Any: The result produced by the operation.
    """
    if name == "is_connected":
        return object.__getattribute__(self, "_is_connected_proxy")
    return object.__getattribute__(self, name)

activate_document async

activate_document(title_or_path: str) -> AdapterResult[dict[str, Any]]

Mock making an already-open document active.

Parameters:

Name	Type	Description	Default
title_or_path	str	Title, full path, or file name of an open document.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def activate_document(
    self, title_or_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock making an already-open document active.

    Args:
        title_or_path (str): Title, full path, or file name of an open
            document.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(0.05)
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )
    target = (title_or_path or "").strip()
    if not target:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="title_or_path is required"
        )

    needle = target.lower()
    match = None
    for model in self._models.values():
        names = {
            model.name.lower(),
            model.path.lower(),
            model.path.rsplit("/", 1)[-1].lower(),
        }
        if needle in names:
            match = model
            break
    if match is None:
        open_titles = ", ".join(m.name for m in self._models.values()) or "none"
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No open document matches {target!r}. Open: {open_titles}",
        )

    self._current_model = match
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"activated": match.name, "verified": True},
        execution_time=0.05,
    )

add_arc async

add_arc(center_x: float, center_y: float, start_x: float, start_y: float, end_x: float, end_y: float) -> AdapterResult[str]

Mock adding a circular arc to sketch.

Parameters:

Name	Type	Description	Default
center_x	float	Arc centre X.	required
center_y	float	Arc centre Y.	required
start_x	float	Arc start point X.	required
start_y	float	Arc start point Y.	required
end_x	float	Arc end point X.	required
end_y	float	Arc end point Y.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_arc(
    self,
    center_x: float,
    center_y: float,
    start_x: float,
    start_y: float,
    end_x: float,
    end_y: float,
) -> AdapterResult[str]:
    """Mock adding a circular arc to sketch.

    Args:
        center_x (float): Arc centre X.
        center_y (float): Arc centre Y.
        start_x (float): Arc start point X.
        start_y (float): Arc start point Y.
        end_x (float): Arc end point X.
        end_y (float): Arc end point Y.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    arc_id = f"Arc_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(arc_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=arc_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_centerline async

add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a construction centerline to sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a construction centerline to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    centerline_id = f"Centerline_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(centerline_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=centerline_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_chamfer async

add_chamfer(distance: float, edge_names: list[str], angle: float = 45.0, flip: bool = False) -> AdapterResult[SolidWorksFeature]

Mock angle-distance chamfer (see :meth:_mock_edge_feature).

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_chamfer(
    self,
    distance: float,
    edge_names: list[str],
    angle: float = 45.0,
    flip: bool = False,
) -> AdapterResult[SolidWorksFeature]:
    """Mock angle-distance chamfer (see :meth:`_mock_edge_feature`)."""
    result = await self._mock_edge_feature("Chamfer", distance, edge_names)
    if result.is_success:
        result.data.parameters.update({"angle": angle, "flip": flip})
    return result

add_circle async

add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Mock adding a circle to sketch.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
radius	float	The radius value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Mock adding a circle to sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    circle_id = f"Circle{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(circle_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=circle_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_datum_tag async

add_datum_tag(label: str, attach_at_mm: tuple[float, float], x_mm: float, y_mm: float) -> AdapterResult[dict[str, Any]]

Mock adding a datum tag; refuses what the real one refuses.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_datum_tag(
    self,
    label: str,
    attach_at_mm: tuple[float, float],
    x_mm: float,
    y_mm: float,
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a datum tag; refuses what the real one refuses."""
    guard = self._mock_doc_error({"Drawing"}, "add_datum_tag")
    if guard is not None:
        return guard
    letter = label.strip().upper()
    if len(letter) != 1 or not letter.isalpha():
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="label must be a single letter, e.g. 'A'",
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"label": letter, "position_mm": [x_mm, y_mm]},
    )

add_drawing_view async

add_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock adding a view of a model to the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path and orientation.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a view of a model to the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path and orientation.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    return self._mock_place_view(payload)

add_ellipse async

add_ellipse(center_x: float, center_y: float, major_axis: float, minor_axis: float) -> AdapterResult[str]

Mock adding an axis-aligned ellipse to sketch.

Parameters:

Name	Type	Description	Default
center_x	float	Ellipse centre X in millimetres.	required
center_y	float	Ellipse centre Y in millimetres.	required
major_axis	float	Full major-axis length in millimetres.	required
minor_axis	float	Full minor-axis length in millimetres.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_ellipse(
    self,
    center_x: float,
    center_y: float,
    major_axis: float,
    minor_axis: float,
) -> AdapterResult[str]:
    """Mock adding an axis-aligned ellipse to sketch.

    Args:
        center_x (float): Ellipse centre X in millimetres.
        center_y (float): Ellipse centre Y in millimetres.
        major_axis (float): Full major-axis length in millimetres.
        minor_axis (float): Full minor-axis length in millimetres.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    ellipse_id = f"Ellipse_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(ellipse_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=ellipse_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_fillet async

add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[SolidWorksFeature]

Mock constant-radius fillet (see :meth:_mock_edge_feature).

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[SolidWorksFeature]:
    """Mock constant-radius fillet (see :meth:`_mock_edge_feature`)."""
    return await self._mock_edge_feature("Fillet", radius, edge_names)

add_gtol async

add_gtol(characteristic: str, tolerance: float, x_mm: float, y_mm: float, diameter_zone: bool = False, material_condition: str = 'none', datums: list[str] | None = None, attach_at_mm: tuple[float, float] | None = None, dimension: tuple[str, str] | None = None) -> AdapterResult[dict[str, Any]]

Mock adding a feature control frame; refuses what the real one refuses.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_gtol(
    self,
    characteristic: str,
    tolerance: float,
    x_mm: float,
    y_mm: float,
    diameter_zone: bool = False,
    material_condition: str = "none",
    datums: list[str] | None = None,
    attach_at_mm: tuple[float, float] | None = None,
    dimension: tuple[str, str] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock adding a feature control frame; refuses what the real one refuses."""
    guard = self._mock_doc_error({"Drawing"}, "add_gtol")
    if guard is not None:
        return guard
    problem = gtol_problem(characteristic, tolerance, material_condition, datums)
    if problem is not None:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "characteristic": characteristic,
            "tolerance": f"{tolerance:g}",
            "diameter_zone": diameter_zone,
            "material_condition": material_condition,
            "datums": [d.strip().upper() for d in datums or []],
            "attached": (
                dimension[1] if dimension is not None else attach_at_mm is not None
            ),
            "position_mm": None if dimension is not None else [x_mm, y_mm],
            "layout": None,
        },
    )

add_line async

add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a line to sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a line to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    line_id = f"Line{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(line_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=line_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_mate async

add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0, face_a: list[float] | None = None, face_b: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Mock mating two components in the active assembly.

Parameters:

Name	Type	Description	Default
component_a	str	First component instance name.	required
component_b	str	Second component instance name.	required
entity_a	str	Named feature on the first component. Defaults to "Front Plane".	'Front Plane'
entity_b	str	Named feature on the second component. Defaults to "Front Plane".	'Front Plane'
mate_type	str	Mate type. Defaults to "coincident".	'coincident'
alignment	str	Mate alignment. Defaults to "aligned".	'aligned'
distance	float	Distance in millimetres, for a distance mate. Defaults to 0.0.	0.0
angle	float	Angle in degrees, for an angle mate. Defaults to 0.0.	0.0
face_a	list[float] | None	A point on a face of the first component (part coordinates, mm), used instead of entity_a.	None
face_b	list[float] | None	The same for the second component.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
    face_a: list[float] | None = None,
    face_b: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock mating two components in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type. Defaults to "coincident".
        alignment (str): Mate alignment. Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.
        face_a (list[float] | None): A point on a face of the first
            component (part coordinates, mm), used instead of entity_a.
        face_b (list[float] | None): The same for the second component.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    from .solidworks.face_selection import mate_entity_label

    known_mate_types = {
        "coincident",
        "concentric",
        "perpendicular",
        "parallel",
        "tangent",
        "distance",
        "angle",
    }
    if mate_type not in known_mate_types:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown mate type '{mate_type}'. "
                f"Use one of: {', '.join(sorted(known_mate_types))}."
            ),
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1
    self._mates.append(
        {"mate_type": mate_type, "components": [component_a, component_b]}
    )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "mate_type": mate_type,
            "alignment": alignment,
            "components": [component_a, component_b],
            "entities": [
                mate_entity_label(entity_a, face_a),
                mate_entity_label(entity_b, face_b),
            ],
            "distance": distance or None,
            "angle": angle or None,
            # The real adapter fills these by comparing every component's
            # Transform2 before and after the mate. The mock has no
            # geometry to move, so it reports "not determinable" rather
            # than True: this field exists precisely so a caller can tell
            # a mate that positioned something from one SolidWorks
            # accepted and ignored, and a mock that always answers True
            # would make that check useless wherever mock mode is used.
            "moved_components": [],
            "geometry_moved": None,
        },
        execution_time=self._delays["model_operation"],
    )

add_note async

add_note(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock placing a text note on the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the text and position.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
    """Mock placing a text note on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the text and position.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    data = payload if isinstance(payload, dict) else {}
    text = data.get("text")
    if not text:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="add_note requires text"
        )

    self._operation_count += 1
    font_points = float(data.get("font_size") or 0.0)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "text": text,
            "position": {
                "x": float(data.get("position_x", 100.0)),
                "y": float(data.get("position_y", 50.0)),
            },
            # The real adapter sets this from IAnnotation::SetPosition's
            # return. Mock mode has no sheet to place anything on, so it
            # reports "not determinable" rather than claiming success at a
            # check it never performed.
            "positioned": None,
            "font_size_points": font_points or None,
        },
        execution_time=self._delays["model_operation"],
    )

add_polygon async

add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Mock adding a regular polygon to sketch.

Parameters:

Name	Type	Description	Default
center_x	float	Polygon centre X in millimetres.	required
center_y	float	Polygon centre Y in millimetres.	required
radius	float	Circumradius in millimetres (distance from centre to each vertex; matches the real adapter's CreatePolygon(..., Inscribed=True) semantics).	required
sides	int	Number of polygon sides.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_polygon(
    self, center_x: float, center_y: float, radius: float, sides: int
) -> AdapterResult[str]:
    """Mock adding a regular polygon to sketch.

    Args:
        center_x (float): Polygon centre X in millimetres.
        center_y (float): Polygon centre Y in millimetres.
        radius (float): Circumradius in millimetres (distance from centre
            to each vertex; matches the real adapter's
            ``CreatePolygon(..., Inscribed=True)`` semantics).
        sides (int): Number of polygon sides.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    # ID format mirrors the real PyWin32 adapter, which uses
    # ``_register_sketch_entity("Polygon", ...)`` (counter-based) so the
    # returned ID is a valid input to downstream sketch_linear_pattern /
    # sketch_circular_pattern / sketch_mirror / sketch_offset calls.
    polygon_id = f"Polygon_{len(self._sketch_entity_ids) + 1}"
    self._sketch_entity_ids.add(polygon_id)
    _ = sides  # informational only; the sides count is no longer part of the ID

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=polygon_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_rectangle async

add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Mock adding a rectangle to sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a rectangle to sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    await asyncio.sleep(self._delays["sketch_operation"])
    self._operation_count += 1

    rect_id = f"Rectangle{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(rect_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=rect_id,
        execution_time=self._delays["sketch_operation"],
    )

add_sketch_constraint async

add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Mock adding a geometric constraint between sketch entities.

Parameters:

Name	Type	Description	Default
entity1	str	Primary sketch-entity ID.	required
entity2	str | None	Secondary sketch-entity ID, or None for single-entity relations (horizontal, vertical, fix).	required
relation_type	str	Constraint name (see RELATION_NAME_MAP).	required
entity3	str | None	Third entity ID — only used by the symmetric relation (the centerline of symmetry). All other relation types reject a non-null entity3.	None

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: SUCCESS with a placeholder constraint ID, or ERROR if no active sketch, the relation_type is unsupported, arity is wrong, or an entity ID is unknown.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Mock adding a geometric constraint between sketch entities.

    Args:
        entity1 (str): Primary sketch-entity ID.
        entity2 (str | None): Secondary sketch-entity ID, or None for
            single-entity relations (horizontal, vertical, fix).
        relation_type (str): Constraint name (see RELATION_NAME_MAP).
        entity3 (str | None): Third entity ID — only used by the
            ``symmetric`` relation (the centerline of symmetry). All
            other relation types reject a non-null ``entity3``.

    Returns:
        AdapterResult[str]: SUCCESS with a placeholder constraint ID, or
            ERROR if no active sketch, the relation_type is unsupported,
            arity is wrong, or an entity ID is unknown.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )

    rt_norm = (relation_type or "").strip().lower()
    if rt_norm not in RELATION_NAME_MAP:
        supported = ", ".join(sorted(RELATION_NAME_MAP))
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unsupported relation type '{relation_type}'. "
                f"Supported: {supported}"
            ),
        )

    # Arity validation — mirror the real adapter
    if rt_norm == "symmetric":
        if entity2 is None or entity3 is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Relation '{relation_type}' requires entity1, "
                    "entity2, and entity3 (the centerline of symmetry)"
                ),
            )
    elif entity3 is not None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Relation '{relation_type}' does not accept entity3 — "
                "only 'symmetric' takes a third entity (the centerline)"
            ),
        )

    # Validate entity IDs against the in-process sketch-entity registry
    # so the mock surfaces the same "Unknown sketch entity" error as the
    # real adapter (which checks adapter._sketch_entities).
    for ent in (entity1, entity2, entity3):
        if ent is not None and ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    constraint_id = f"Constraint_{relation_type}_{random.randint(1000, 9999)}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=constraint_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

add_sketch_line async

add_sketch_line(x1: float, y1: float, x2: float, y2: float, construction: bool = False) -> AdapterResult[dict[str, Any]]

Legacy compatibility wrapper around add_line.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required
construction	bool	The construction value. Defaults to False.	False

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_sketch_line(
    self,
    x1: float,
    y1: float,
    x2: float,
    y2: float,
    construction: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Legacy compatibility wrapper around add_line.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.
        construction (bool): The construction value. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    result = await self.add_line(x1, y1, x2, y2)
    if not result.is_success:
        return AdapterResult(
            status=result.status,
            error=result.error,
            execution_time=result.execution_time,
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "id": result.data,
            "start": {"x": x1, "y": y1},
            "end": {"x": x2, "y": y2},
            "construction": construction,
        },
        execution_time=result.execution_time,
    )

add_spline async

add_spline(points: list[dict[str, float]]) -> AdapterResult[str]

Mock adding a NURBS spline through the supplied points.

Parameters:

Name	Type	Description	Default
points	list[dict[str, float]]	Ordered control points with "x" / "y" keys. Minimum 2 points.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
    """Mock adding a NURBS spline through the supplied points.

    Args:
        points (list[dict[str, float]]): Ordered control points with
            ``"x"`` / ``"y"`` keys. Minimum 2 points.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if len(points) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="add_spline requires at least 2 points",
        )
    # Match the real adapter's point contract: each dict must carry
    # both ``x`` and ``y`` keys, or the live impl raises KeyError on
    # ``point["x"]``. Validating here keeps mock/live parity so tests
    # that pass against the mock won't fail live on malformed input.
    for index, point in enumerate(points):
        if not isinstance(point, dict) or "x" not in point or "y" not in point:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"add_spline point at index {index} is missing "
                    "required 'x' and/or 'y' keys"
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    spline_id = f"Spline_{random.randint(1000, 9999)}"
    self._sketch_entity_ids.add(spline_id)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=spline_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

arrange_dimensions async

arrange_dimensions(view_name: str | None = None) -> AdapterResult[dict[str, Any]]

Mock arranging drawing dimensions: reports a clean layout.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def arrange_dimensions(
    self, view_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock arranging drawing dimensions: reports a clean layout."""
    guard = self._mock_doc_error({"Drawing"}, "arrange_dimensions")
    if guard is not None:
        return guard
    if view_name and view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
            ),
        )
    counts = getattr(self, "_view_dimensions", {})
    total = sum(n for v, n in counts.items() if not view_name or v == view_name)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "dimensions": total,
            "moved": total,
            "unplaced": [],
            "overlaps_before": total,
            "overlaps_after": 0,
            "remaining_overlaps": [],
            "sheet_size_m": [0.42, 0.297],
        },
    )

auto_center_marks async

auto_center_marks(view_name: str, mark_holes: bool = True, mark_fillets: bool = False, mark_slots: bool = True) -> AdapterResult[dict[str, Any]]

Mock auto-inserting centre marks on a drawing view.

The mock has no geometry, so it cannot know how many circular features a view holds - it mirrors the live adapter's refusals (not a drawing, no feature type selected, unknown view) and, on a valid request, records a nominal centre-mark increase per view so before/after deltas stay monotonic across calls.

Parameters:

Name	Type	Description	Default
view_name	str	Name of a view on the active drawing.	required
mark_holes	bool	Mark holes / bores.	True
mark_fillets	bool	Mark fillets.	False
mark_slots	bool	Mark slots.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The view, the feature types acted
AdapterResult[dict[str, Any]]	on, and before/after centre-mark counts, or an error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def auto_center_marks(
    self,
    view_name: str,
    mark_holes: bool = True,
    mark_fillets: bool = False,
    mark_slots: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock auto-inserting centre marks on a drawing view.

    The mock has no geometry, so it cannot know how many circular
    features a view holds - it mirrors the live adapter's refusals (not
    a drawing, no feature type selected, unknown view) and, on a valid
    request, records a nominal centre-mark increase per view so
    before/after deltas stay monotonic across calls.

    Args:
        view_name (str): Name of a view on the active drawing.
        mark_holes (bool): Mark holes / bores.
        mark_fillets (bool): Mark fillets.
        mark_slots (bool): Mark slots.

    Returns:
        AdapterResult[dict[str, Any]]: The view, the feature types acted
        on, and before/after centre-mark counts, or an error.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)

    model = self._current_model
    if model is None or getattr(model, "type", None) != "Drawing":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="auto_center_marks requires an active drawing document",
        )
    if not (mark_holes or mark_fillets or mark_slots):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "Select at least one feature type: mark_holes, "
                "mark_fillets or mark_slots."
            ),
        )
    if view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r} on the active drawing. "
                f"Views: {', '.join(self._drawing_views) or 'none'}"
            ),
        )

    self._operation_count += 1
    before = self._center_marks.get(view_name, 0)
    # Nominal: two marks per selected feature type, added once.
    added = 0 if before else 2 * sum((mark_holes, mark_fillets, mark_slots))
    after = before + added
    self._center_marks[view_name] = after

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "view": view_name,
            "feature_types": [
                label
                for label, on in (
                    ("holes", mark_holes),
                    ("fillets", mark_fillets),
                    ("slots", mark_slots),
                )
                if on
            ],
            "center_marks_before": before,
            "center_marks_after": after,
            "center_marks_added": added,
        },
        execution_time=self._delays["model_operation"] / 2,
    )

check_interference async

check_interference(params: Any = None) -> AdapterResult[dict[str, Any]]

Mock checking the active assembly for interfering components.

Parameters:

Name	Type	Description	Default
params	Any	Optional settings; coincident, components.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def check_interference(
    self, params: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock checking the active assembly for interfering components.

    Args:
        params (Any): Optional settings; ``coincident``, ``components``.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    options = params if isinstance(params, dict) else {}

    if len(self._components) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "Interference detection needs at least two components; the "
                f"assembly has {len(self._components)}."
            ),
        )

    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            # The real adapter gets this from SolidWorks' interference
            # engine. The mock has no geometry, so it cannot know whether
            # anything overlaps and says so rather than reporting a clean
            # assembly it never checked - a mock that always answered
            # False would make this tool useless wherever mock mode runs.
            "interference_found": None,
            "interference_count": None,
            "interferences": [],
            "coincident_treated_as_interference": bool(
                options.get("coincident", False)
            ),
            "scope": "whole assembly",
            "tolerance_applied": None,
        },
        execution_time=self._delays["model_operation"],
    )

check_sketch_fully_defined async

check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Mock check for sketch definition status.

Parameters:

Name	Type	Description	Default
sketch_name	str | None	Optional sketch name to inspect. Defaults to None.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Definition status payload.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock check for sketch definition status.

    Args:
        sketch_name (str | None): Optional sketch name to inspect. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: Definition status payload.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 3)
    self._operation_count += 1

    resolved_name = sketch_name or self._current_sketch or "Sketch1"
    if sketch_name and sketch_name not in self._sketches:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Sketch not found: {sketch_name}",
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "sketch_name": resolved_name,
            "is_fully_defined": True,
            "definition_state": "fully_defined",
            "source": "mock",
            "raw_status": True,
        },
        execution_time=self._delays["sketch_operation"] / 3,
    )

close_model async

close_model(save: bool = False) -> AdapterResult[None]

Mock closing the current model.

Parameters:

Name	Type	Description	Default
save	bool	The save value. Defaults to False.	False

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Mock closing the current model.

    Args:
        save (bool): The save value. Defaults to False.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.WARNING, error="No active model to close"
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    if save:
        # Simulate save operation
        await asyncio.sleep(self._delays["model_operation"])

    self._current_model = None

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=self._delays["model_operation"],
    )

connect async

connect() -> None

Mock connection to SolidWorks.

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def connect(self) -> None:
    """Mock connection to SolidWorks.

    Returns:
        None: None.
    """
    await asyncio.sleep(self._delays["connect"])
    self._connected = True

    # Initialize some sample data
    self._dimensions = {
        "D1@Sketch1": 10.0,
        "D2@Sketch1": 20.0,
        "D1@Boss-Extrude1": 50.0,
    }

create_assembly async

create_assembly(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new assembly.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_assembly(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new assembly.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Assembly{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.sldasm",
        name=f"{model_id}",
        type="Assembly",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_axis async

create_axis(reference: str) -> AdapterResult[dict[str, Any]]

Mock creating a reference axis along a principal direction.

Mirrors the live adapter's plane-pair mapping (_AXIS_PLANE_PAIRS in solidworks/features.py, imported here directly so the two can never drift apart) and validation: only x/y/z (case-insensitive, leading ± stripped) are accepted.

Parameters:

Name	Type	Description	Default
reference	str	"x", "y" or "z" (case-insensitive; leading ± stripped).	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The plane pair used and the
AdapterResult[dict[str, Any]]	feature counter before/after, or error for an unknown reference.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_axis(self, reference: str) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference axis along a principal direction.

    Mirrors the live adapter's plane-pair mapping (``_AXIS_PLANE_PAIRS``
    in ``solidworks/features.py``, imported here directly so the two can
    never drift apart) and validation: only ``x``/``y``/``z``
    (case-insensitive, leading +/- stripped) are accepted.

    Args:
        reference (str): "x", "y" or "z" (case-insensitive; leading +/-
            stripped).

    Returns:
        AdapterResult[dict[str, Any]]: The plane pair used and the
        feature counter before/after, or error for an unknown reference.
    """
    key = str(reference or "").strip().lower().lstrip("+-")
    if key not in _AXIS_PLANE_PAIRS:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown axis reference '{reference}'. "
                f"Use one of: {', '.join(sorted(_AXIS_PLANE_PAIRS))}."
            ),
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    before = self._feature_tree_count
    self._feature_tree_count += 1
    after = self._feature_tree_count

    plane_a, plane_b = _AXIS_PLANE_PAIRS[key]

    # Invent a sequential "AxisN" name, tracked on self._axes, the same
    # way create_reference_plane invents "PlaneN" names on
    # self._reference_planes. The live adapter reads the new axis's name
    # from the end of the feature tree (InsertAxis2 returns only a bool).
    self._axes.append(f"Axis{len(self._axes) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._axes[-1],
            "reference": key,
            "planes": [plane_a, plane_b],
            "features_before": before,
            "features_after": after,
        },
        execution_time=self._delays["feature_operation"],
    )

create_drawing async

create_drawing(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new drawing.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_drawing(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new drawing.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Drawing{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.slddrw",
        name=f"{model_id}",
        type="Drawing",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_drawing_view async

create_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock placing a view of a model on the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path and orientation.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock placing a view of a model on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path and orientation.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    return self._mock_place_view(payload)

create_extrusion async

create_extrusion(params: ExtrusionParameters | str, depth: float | None = None, direction: str | None = None) -> AdapterResult[SolidWorksFeature]

Mock creating an extrusion feature.

Parameters:

Name	Type	Description	Default
params	ExtrusionParameters | str	The params value.	required
depth	float | None	The depth value. Defaults to None.	None
direction	str | None	The direction value. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_extrusion(
    self,
    params: ExtrusionParameters | str,
    depth: float | None = None,
    direction: str | None = None,
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating an extrusion feature.

    Args:
        params (ExtrusionParameters | str): The params value.
        depth (float | None): The depth value. Defaults to None.
        direction (str | None): The direction value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    if isinstance(params, str):
        params = ExtrusionParameters(depth=depth or 0.0)
    sketch = self._mock_named_sketch(
        getattr(params, "sketch_name", None), "extrude"
    )
    if isinstance(sketch, AdapterResult):
        return sketch

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Extrude{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Extrusion",
        id=str(uuid.uuid4()),
        parameters={
            "depth": params.depth,
            "direction": direction or "blind",
            "draft_angle": params.draft_angle,
            "reverse_direction": params.reverse_direction,
            "both_directions": params.both_directions,
            "end_condition": "MidPlane"
            if params.both_directions
            else params.end_condition,
            "thin_feature": params.thin_feature,
            "thin_thickness": params.thin_thickness,
            "thin_side": params.thin_side if params.thin_feature else None,
            "sketch_name": sketch,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_loft async

create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a loft feature.

Parameters:

Name	Type	Description	Default
params	LoftParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a loft feature.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Loft{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Loft",
        id=str(uuid.uuid4()),
        parameters={
            "profiles": params.profiles,
            "guide_curves": params.guide_curves,
            "start_tangent": params.start_tangent,
            "end_tangent": params.end_tangent,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_part async

create_part(name: str | None = None, units: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Mock creating a new part.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
units	str | None	The units value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_part(
    self,
    name: str | None = None,
    units: str | None = None,
    template: str | None = None,
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new part.

    Args:
        name (str | None): The name value. Defaults to None.
        units (str | None): The units value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    token = "mm"
    if units is not None and str(units).strip():
        token = _normalise_mock_unit_system(str(units))
        if token is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unrecognised units {units!r}. "
                    "Expected one of: mm, cm, m, in, ft."
                ),
            )

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    model_id = name or f"Part{len(self._models) + 1}"
    model = SolidWorksModel(
        path=f"Mock://{model_id}.sldprt",
        name=f"{model_id}",
        type="Part",
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "mock": True,
            "units": token,
            "template": template,
        },
    )

    self._current_model = model
    self._models[model.path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

create_reference_plane async

create_reference_plane(reference: str, offset: float = 0.0, angle: float = 0.0, flip: bool = False, axis: str | None = None, face_point: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Mock creating a reference plane offset from, angled to, or on a face.

Refuses exactly what the live adapter refuses (the shared reference_plane_refusal in solidworks/features.py). On success, invents a sequential PlaneN name tracked on self._reference_planes and advances the shared mock feature-tree counter so features_before/features_after differ by exactly one, the same signal the live adapter derives from IFeatureManager::GetFeatureCount.

Parameters:

Name	Type	Description	Default
reference	str	Name of the reference plane.	required
offset	float	Offset distance in millimetres. Defaults to 0.0.	0.0
angle	float	Angle in degrees about axis. Defaults to 0.0.	0.0
flip	bool	Reverse the offset direction. Defaults to False.	False
axis	str | None	Axis to rotate about, for an angle.	None
face_point	list[float] | None	Point on a flat face, in mm.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The new plane's name and
AdapterResult[dict[str, Any]]	parameters, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_reference_plane(
    self,
    reference: str,
    offset: float = 0.0,
    angle: float = 0.0,
    flip: bool = False,
    axis: str | None = None,
    face_point: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference plane offset from, angled to, or on a face.

    Refuses exactly what the live adapter refuses (the shared
    ``reference_plane_refusal`` in ``solidworks/features.py``). On
    success, invents a sequential ``PlaneN`` name tracked on
    ``self._reference_planes`` and advances the shared mock feature-tree
    counter so ``features_before``/``features_after`` differ by exactly
    one, the same signal the live adapter derives from
    ``IFeatureManager::GetFeatureCount``.

    Args:
        reference (str): Name of the reference plane.
        offset (float): Offset distance in millimetres. Defaults to 0.0.
        angle (float): Angle in degrees about ``axis``. Defaults to 0.0.
        flip (bool): Reverse the offset direction. Defaults to False.
        axis (str | None): Axis to rotate about, for an angle.
        face_point (list[float] | None): Point on a flat face, in mm.

    Returns:
        AdapterResult[dict[str, Any]]: The new plane's name and
        parameters, or error.
    """
    from .solidworks.features import reference_plane_refusal

    refusal = reference_plane_refusal(reference, offset, angle, axis, face_point)
    if refusal is not None:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=refusal)

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    before = self._feature_tree_count
    self._feature_tree_count += 1
    after = self._feature_tree_count

    self._reference_planes.append(f"Plane{len(self._reference_planes) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._reference_planes[-1],
            "reference": reference if face_point is None else None,
            "face_point": face_point,
            "offset": offset or None,
            "angle": angle or None,
            "axis": axis if angle else None,
            "flip": flip,
            "features_before": before,
            "features_after": after,
        },
        execution_time=self._delays["feature_operation"],
    )

create_reference_point async

create_reference_point(mode: str, x: float, y: float, z: float, distance: float | None = None, percent: float | None = None) -> AdapterResult[dict[str, Any]]

Mock creating a reference point on the active part.

The mock has no geometry, so it cannot resolve a coordinate to an edge/face - it mirrors the live adapter's validation (unknown mode, the distance/percent XOR, range checks) and, on a valid request, bumps the feature counter the way InsertReferencePoint would.

Parameters:

Name	Type	Description	Default
mode	str	"along_curve" or "face_center".	required
x	float	X of a point on the target entity, in millimetres.	required
y	float	Y of a point on the target entity, in millimetres.	required
z	float	Z of a point on the target entity, in millimetres.	required
distance	float | None	For "along_curve", offset from the edge start in millimetres.	None
percent	float | None	For "along_curve", 0-100 of edge length.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The mode and feature counts, or an
AdapterResult[dict[str, Any]]	error matching the live adapter's refusals.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_reference_point(
    self,
    mode: str,
    x: float,
    y: float,
    z: float,
    distance: float | None = None,
    percent: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock creating a reference point on the active part.

    The mock has no geometry, so it cannot resolve a coordinate to an
    edge/face - it mirrors the live adapter's *validation* (unknown mode,
    the distance/percent XOR, range checks) and, on a valid request,
    bumps the feature counter the way ``InsertReferencePoint`` would.

    Args:
        mode (str): "along_curve" or "face_center".
        x (float): X of a point on the target entity, in millimetres.
        y (float): Y of a point on the target entity, in millimetres.
        z (float): Z of a point on the target entity, in millimetres.
        distance (float | None): For "along_curve", offset from the edge
            start in millimetres.
        percent (float | None): For "along_curve", 0-100 of edge length.

    Returns:
        AdapterResult[dict[str, Any]]: The mode and feature counts, or an
        error matching the live adapter's refusals.
    """
    key = str(mode or "").strip().lower()
    if key not in ("along_curve", "face_center"):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(f"Unknown mode {mode!r}. Use 'along_curve' or 'face_center'."),
        )
    if key == "along_curve":
        if (distance is None) == (percent is None):
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="along_curve needs exactly one of distance or percent",
            )
        if distance is not None and float(distance) <= 0.0:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="distance must be positive",
            )
        if percent is not None and not 0.0 < float(percent) < 100.0:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error="percent must be between 0 and 100 (exclusive)",
            )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1
    before = self._feature_tree_count
    self._feature_tree_count += 1
    self._reference_points.append(f"Point{len(self._reference_points) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": self._reference_points[-1],
            "mode": key,
            "at_mm": [x, y, z],
            "distance_mm": distance if key == "along_curve" else None,
            "percent": percent if key == "along_curve" else None,
            "features_before": before,
            "features_after": self._feature_tree_count,
        },
        execution_time=self._delays["feature_operation"],
    )

create_revolve async

create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a revolve feature.

Parameters:

Name	Type	Description	Default
params	RevolveParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a revolve feature.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    sketch = self._mock_named_sketch(
        getattr(params, "sketch_name", None), "revolve"
    )
    if isinstance(sketch, AdapterResult):
        return sketch
    axis = getattr(params, "axis_entity", None)
    if axis and axis not in self._axes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Axis '{axis}' is not a reference axis in the "
            "model. Create one with create_axis.",
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Revolve{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Revolve",
        id=str(uuid.uuid4()),
        parameters={
            "angle": params.angle,
            "reverse_direction": params.reverse_direction,
            "both_directions": params.both_directions,
            "thin_feature": params.thin_feature,
            "thin_thickness": params.thin_thickness,
            "sketch_name": sketch,
            "axis_entity": axis,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_sketch async

create_sketch(plane: str) -> AdapterResult[dict[str, Any]]

Mock creating a sketch.

Parameters:

Name	Type	Description	Default
plane	str	The plane value.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_sketch(self, plane: str) -> AdapterResult[dict[str, Any]]:  # type: ignore[override]
    """Mock creating a sketch.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        # Legacy tests start sketching immediately after connect.
        await self.create_part()

    await asyncio.sleep(self._delays["sketch_operation"])
    self._operation_count += 1

    sketch_id = f"Sketch{len(self._sketches) + 1}"
    self._sketches[sketch_id] = plane
    self._current_sketch = sketch_id

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "id": sketch_id,
            "name": sketch_id,
            "sketch_name": sketch_id,
            "plane": plane,
        },
        execution_time=self._delays["sketch_operation"],
    )

create_standard_drawing async

create_standard_drawing(model_path: str, output_dir: str | None = None, title: str | None = None, subtitle: str | None = None, drawing_number: str | None = None, author: str = '', revision: str = 'A', company: str = '', drawn_date: str | None = None, notes: list[str] | None = None, include_isometric: bool = True, write_model_properties: bool = True, title_block_text_height_mm: float | None = None, include_bom: bool = False) -> AdapterResult[dict[str, Any]]

Mock standard A3 drawing: validates inputs, writes nothing to disk.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_standard_drawing(
    self,
    model_path: str,
    output_dir: str | None = None,
    title: str | None = None,
    subtitle: str | None = None,
    drawing_number: str | None = None,
    author: str = "",
    revision: str = "A",
    company: str = "",
    drawn_date: str | None = None,
    notes: list[str] | None = None,
    include_isometric: bool = True,
    write_model_properties: bool = True,
    title_block_text_height_mm: float | None = None,
    include_bom: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Mock standard A3 drawing: validates inputs, writes nothing to disk."""
    if not os.path.isfile(model_path):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Model file not found: {model_path}",
        )
    stem = os.path.splitext(os.path.basename(model_path))[0]
    number = drawing_number or f"{stem.upper().replace(' ', '-')}-Rev{revision}-01"
    out_dir = output_dir or os.path.dirname(model_path)
    views = {
        "Drawing View1": {"role": "front", "caption": "FRONT VIEW"},
        "Drawing View2": {"role": "plan", "caption": "TOP VIEW"},
        "Drawing View3": {"role": "side", "caption": "SIDE VIEW"},
    }
    if include_isometric:
        views["Drawing View4"] = {"role": "iso", "caption": "ISOMETRIC VIEW"}
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "scale": "1:1",
            "isometric_scale": "1:1" if include_isometric else None,
            "views": views,
            "hidden_lines_visible": {
                n: True for n, v in views.items() if v["role"] != "iso"
            },
            "bom": {"bom_type": "top_level_only", "table_box_mm": None}
            if include_bom
            else None,
            "overlap_check": {"overlaps_after": 0, "annotation_overlaps": []},
            "drawing_number": number,
            "drawing_path": os.path.join(out_dir, f"{number}.SLDDRW"),
            "pdf_path": os.path.join(out_dir, f"{number}.pdf"),
            "properties_written": {
                "model": {"Description": title or stem}
                if write_model_properties
                else {},
                "drawing": {"DrawnBy": author, "Revision": revision},
            },
            "notes": ["NOTES", *[n.upper() for n in (notes or [])]],
            "title_block": {
                "drawing number": {"found": True, "fits": True},
                "title": {"found": True, "fits": True},
            },
            "mock": True,
        },
    )

create_sweep async

create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Mock creating a sweep feature.

Parameters:

Name	Type	Description	Default
params	SweepParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Mock creating a sweep feature.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    feature_id = f"Boss-Sweep{len(self._features) + 1}"
    feature = SolidWorksFeature(
        name=feature_id,
        type="Sweep",
        id=str(uuid.uuid4()),
        parameters={
            "path": params.path,
            "twist_along_path": params.twist_along_path,
            "twist_angle": params.twist_angle,
        },
        properties={"created": datetime.now().isoformat(), "mock": True},
    )

    feature_key = feature.id or feature.name
    self._features[feature_key] = feature

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature,
        execution_time=self._delays["feature_operation"],
    )

create_technical_drawing async

create_technical_drawing(payload: Any = None) -> AdapterResult[dict[str, Any]]

Mock laying out the three standard views of a model.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path and projection.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def create_technical_drawing(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Mock laying out the three standard views of a model.

    Args:
        payload (Any): Tool payload carrying the model path and projection.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    data = payload if isinstance(payload, dict) else {}
    model_path = data.get("model_path") or data.get("model_file")
    if not model_path:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="A model path is required (model_path or model_file)",
        )

    third_angle = bool(data.get("third_angle", True))
    if str(data.get("projection", "")).lower() in {"first", "first_angle"}:
        third_angle = False

    before = len(self._drawing_views)
    added = [f"Drawing View{before + offset}" for offset in (1, 2, 3)]
    self._drawing_views.extend(added)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "views": added,
            "model_path": model_path,
            "projection": "third_angle" if third_angle else "first_angle",
            "views_before": before,
            "views_after": len(self._drawing_views),
        },
        execution_time=self._delays["model_operation"],
    )

delete_feature async

delete_feature(name: str) -> AdapterResult[dict[str, Any]]

Mock deleting a named feature from the active model.

Parameters:

Name	Type	Description	Default
name	str	Feature or sketch name.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def delete_feature(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Mock deleting a named feature from the active model.

    Args:
        name (str): Feature or sketch name.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    # _features is keyed by an internal id, so resolve by feature name.
    before = [f.name for f in self._features.values()]
    key = next((k for k, f in self._features.items() if f.name == name), None)
    if key is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Feature not found: {name}. "
                f"Available: {', '.join(before) or 'none'}"
            ),
        )

    del self._features[key]
    self._suppressed_features.discard(name)
    self._operation_count += 1
    after = [f.name for f in self._features.values()]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "deleted": name,
            "removed_features": [n for n in before if n not in after],
            "features_before": len(before),
            "features_after": len(after),
        },
        execution_time=self._delays["model_operation"],
    )

disconnect async

disconnect() -> None

Mock disconnection from SolidWorks.

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def disconnect(self) -> None:
    """Mock disconnection from SolidWorks.

    Returns:
        None: None.
    """
    self._connected = False
    self._current_model = None
    self._models.clear()
    self._features.clear()
    self._sketches.clear()
    self._current_sketch = None
    self._selection.clear()

exit_sketch async

exit_sketch() -> AdapterResult[None]

Mock exiting sketch mode.

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def exit_sketch(self) -> AdapterResult[None]:
    """Mock exiting sketch mode.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.WARNING, error="No active sketch to exit"
        )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._current_sketch = None

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=self._delays["sketch_operation"] / 2,
    )

export_file async

export_file(file_path: str, format_type: str) -> AdapterResult[None]

Mock exporting a file.

Parameters:

Name	Type	Description	Default
file_path	str	Path to the target file.	required
format_type	str	The format type value.	required

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Mock exporting a file.

    Args:
        file_path (str): Path to the target file.
        format_type (str): The format type value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    # Simulate export time based on format
    export_times = {
        "step": 2.0,
        "iges": 1.5,
        "stl": 1.0,
        "pdf": 0.5,
        "jpg": 0.3,
        "glb": 1.2,
        "gltf": 1.2,
    }

    format_lower = format_type.lower()
    delay = export_times.get(format_lower, 1.0)

    await asyncio.sleep(delay)
    self._operation_count += 1

    # Write a minimal placeholder file so callers that check existence get a valid result
    if format_lower == "stl":
        import pathlib

        out = pathlib.Path(file_path)
        out.parent.mkdir(parents=True, exist_ok=True)
        # Minimal ASCII STL — a single unit triangle (mock geometry placeholder)
        out.write_text(
            "solid mock\n"
            "  facet normal 0 0 1\n"
            "    outer loop\n"
            "      vertex 0 0 0\n"
            "      vertex 10 0 0\n"
            "      vertex 5 10 0\n"
            "    endloop\n"
            "  endfacet\n"
            "  facet normal 0 0 1\n"
            "    outer loop\n"
            "      vertex 0 0 0\n"
            "      vertex 10 0 0\n"
            "      vertex 5 0 10\n"
            "    endloop\n"
            "  endfacet\n"
            "endsolid mock\n",
            encoding="utf-8",
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=None,
        execution_time=delay,
        metadata={"exported_format": format_type, "file_path": file_path},
    )

export_flat_pattern async

export_flat_pattern(file_path: str) -> AdapterResult[dict[str, Any]]

Mock flat-pattern export: validates the target, writes nothing.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_flat_pattern(
    self, file_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock flat-pattern export: validates the target, writes nothing."""
    guard = self._mock_doc_error({"Part"}, "export_flat_pattern")
    if guard is not None:
        return guard
    if not file_path.lower().endswith((".dxf", ".dwg")):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="file_path must end in .dxf or .dwg",
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"file_path": file_path, "size_bytes": 0, "mock": True},
    )

export_image async

export_image(payload: dict) -> AdapterResult[dict]

Mock export of a PNG/JPG viewport screenshot.

Parameters:

Name	Type	Description	Default
payload	dict	The payload value.	required

Returns:

Type	Description
AdapterResult[dict]	AdapterResult[dict]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Mock export of a PNG/JPG viewport screenshot.

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    import pathlib

    file_path = payload.get("file_path", "")
    width = int(payload.get("width", 1280))
    height = int(payload.get("height", 720))
    orientation = str(payload.get("view_orientation", "current"))

    await asyncio.sleep(0.3)
    self._operation_count += 1

    out = pathlib.Path(file_path)
    out.parent.mkdir(parents=True, exist_ok=True)

    # Write a valid 1×1 white PNG binary so UI image tags don't break
    _PNG_1X1_WHITE = (
        b"\x89PNG\r\n\x1a\n"  # PNG signature
        b"\x00\x00\x00\rIHDR"  # IHDR chunk length+type
        b"\x00\x00\x00\x01\x00\x00\x00\x01"  # 1x1
        b"\x08\x02\x00\x00\x00\x90wS\xde"  # 8-bit RGB + CRC
        b"\x00\x00\x00\x0cIDATx\x9cc\xf8\xff\xff\xff\x00\x05\xfe\x02\xfe\xdc\xcaY\xe7"  # IDAT
        b"\x00\x00\x00\x00IEND\xaeB`\x82"  # IEND
    )
    out.write_bytes(_PNG_1X1_WHITE)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "file_path": file_path,
            "format": "PNG",
            "dimensions": f"{width}x{height}",
            "view": orientation,
        },
        execution_time=0.3,
        metadata={"mock": True, "orientation": orientation},
    )

get_application_info async

get_application_info() -> AdapterResult[dict[str, Any]]

Mock SolidWorks description: a fixed 2026 install in English.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_application_info(self) -> AdapterResult[dict[str, Any]]:
    """Mock SolidWorks description: a fixed 2026 install in English.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "revision": "34.0.0",
            "language": "english",
            "templates": {
                kind: {"file_name": f"{kind}.{ext}", "exists": True}
                for kind, ext in (
                    ("part", "prtdot"),
                    ("assembly", "asmdot"),
                    ("drawing", "drwdot"),
                )
            },
        },
    )

get_custom_properties async

get_custom_properties(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock reading custom properties.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_custom_properties(
    self, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock reading custom properties."""
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    store = getattr(self, "_custom_properties", {})
    props = store.get((self._mock_doc_key(), configuration or ""), {})
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "configuration": configuration or "",
            "properties": {
                k: {"value": v, "resolved": v} for k, v in props.items()
            },
        },
    )

get_dimension async

get_dimension(name: str) -> AdapterResult[dict[str, Any]]

Mock getting a dimension value; the mock's dimensions are lengths.

Parameters:

Name	Type	Description	Default
name	str	The name value.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: value in mm and units: "mm".

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_dimension(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Mock getting a dimension value; the mock's dimensions are lengths.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[dict[str, Any]]: ``value`` in mm and ``units: "mm"``.
    """
    await asyncio.sleep(0.05)  # Very fast operation
    self._operation_count += 1

    if name in self._dimensions:
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data={"value": self._dimensions[name], "units": "mm"},
            execution_time=0.05,
        )
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Dimension '{name}' not found; list the names with "
                "list_model_dimensions"
            ),
        )

get_mass_properties async

get_mass_properties() -> AdapterResult[MassProperties]

Mock getting mass properties.

Returns:

Type	Description
AdapterResult[MassProperties]	AdapterResult[MassProperties]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Mock getting mass properties.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    # Generate realistic mock data
    properties = MassProperties(
        volume=random.uniform(1000, 100000),  # mm³
        surface_area=random.uniform(1000, 50000),  # mm²
        mass=random.uniform(0.1, 50.0),  # kg (assuming typical density)
        center_of_mass=[
            random.uniform(-100, 100),
            random.uniform(-100, 100),
            random.uniform(-100, 100),
        ],
        moments_of_inertia={
            "Ixx": random.uniform(1e6, 1e9),
            "Iyy": random.uniform(1e6, 1e9),
            "Izz": random.uniform(1e6, 1e9),
            "Ixy": random.uniform(-1e8, 1e8),
            "Ixz": random.uniform(-1e8, 1e8),
            "Iyz": random.uniform(-1e8, 1e8),
        },
    )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=properties,
        execution_time=self._delays["feature_operation"],
    )

get_material async

get_material(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock reading the active part material.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_material(
    self, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock reading the active part material."""
    guard = self._mock_doc_error({"Part"}, "get_material")
    if guard is not None:
        return guard
    assigned = getattr(self, "_materials", {}).get(self._mock_doc_key())
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "material": assigned["name"] if assigned else None,
            "database": assigned["database"] if assigned else None,
            "density_kg_m3": (
                self._MOCK_DENSITIES.get(assigned["name"]) if assigned else None
            ),
            "configuration": configuration,
        },
    )

get_model_geometry_summary async

get_model_geometry_summary() -> AdapterResult[dict[str, Any]]

Mock summary of the active part or assembly.

The mock has no geometry, so volume, bounding box and body count are None ("not determinable") rather than invented numbers a caller could mistake for a measurement. Component and mate counts are real: they come from insert_component and add_mate this session.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
    """Mock summary of the active part or assembly.

    The mock has no geometry, so volume, bounding box and body count are
    ``None`` ("not determinable") rather than invented numbers a caller
    could mistake for a measurement. Component and mate counts are real:
    they come from ``insert_component`` and ``add_mate`` this session.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    guard = self._mock_doc_error({"Part", "Assembly"}, "get_model_geometry_summary")
    if guard is not None:
        return guard
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    is_assembly = self._current_model.type == "Assembly"
    summary: dict[str, Any] = {
        "document_type": "assembly" if is_assembly else "part",
        "volume_mm3": None,
        "bounding_box_mm": None,
        "bounding_box_method": None,
        "solid_body_count": None,
    }
    if is_assembly:
        summary["component_count"] = len(self._components)
        summary["mate_count"] = len(self._mates)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=summary,
        execution_time=self._delays["model_operation"] / 2,
    )

get_model_info async

get_model_info() -> AdapterResult[dict[str, Any]]

Mock metadata for the currently active model.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
    """Mock metadata for the currently active model.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    model = self._current_model
    feature_count = len(self._features)
    info = {
        "title": model.name,
        "path": model.path,
        "type": model.type,
        "configuration": model.configuration or "Default",
        "is_dirty": False,
        "feature_count": feature_count,
        "rebuild_status": 0,
    }

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=info,
        execution_time=self._delays["model_operation"] / 2,
    )

get_selected_entities async

get_selected_entities() -> AdapterResult[list[dict[str, Any]]]

Mock UI selection — always reports one canned face and one canned edge.

There's no real UI to read a selection from in mock mode, so this returns a stable, plausible-shaped fixture rather than an empty list, so callers exercising this tool in tests get realistic field names.

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def get_selected_entities(self) -> AdapterResult[list[dict[str, Any]]]:
    """Mock UI selection — always reports one canned face and one canned edge.

    There's no real UI to read a selection from in mock mode, so this
    returns a stable, plausible-shaped fixture rather than an empty list,
    so callers exercising this tool in tests get realistic field names.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=[
            {
                "index": 1,
                "type": "FACE",
                "bounding_box_mm": {
                    "min": [0.0, 0.0, 0.0],
                    "max": [30.0, 30.0, 0.0],
                },
                "center_mm": [15.0, 15.0, 0.0],
                "area_mm2": 900.0,
                "normal": [0.0, 0.0, 1.0],
            },
            {
                "index": 2,
                "type": "EDGE",
                "start_mm": [0.0, 0.0, -15.0],
                "end_mm": [30.0, 0.0, -15.0],
                "length_mm": 30.0,
            },
        ],
        execution_time=self._delays["feature_operation"] / 4,
    )

health_check async

health_check() -> AdapterHealth

Get mock health status.

Returns:

Name	Type	Description
AdapterHealth	AdapterHealth	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def health_check(self) -> AdapterHealth:
    """Get mock health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    error_count = int(self._metrics["errors_count"])
    success_count = int(
        self._metrics["operations_count"] - self._metrics["errors_count"]
    )
    return AdapterHealth(
        healthy=self._connected,
        last_check=datetime.now(),
        error_count=error_count,
        success_count=success_count,
        average_response_time=self._metrics["average_response_time"],
        connection_status="connected" if self._connected else "disconnected",
        metrics={
            "adapter_type": "mock",
            "operations_count": self._operation_count,
            "models_count": len(self._models),
            "features_count": len(self._features),
            "sketches_count": len(self._sketches),
        },
    )

insert_bom_table async

insert_bom_table(view_name: str, template_path: str | None = None, bom_type: str = 'top_level_only', x_mm: float | None = None, y_mm: float | None = None) -> AdapterResult[dict[str, Any]]

Mock inserting a BOM table.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_bom_table(
    self,
    view_name: str,
    template_path: str | None = None,
    bom_type: str = "top_level_only",
    x_mm: float | None = None,
    y_mm: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock inserting a BOM table."""
    guard = self._mock_doc_error({"Drawing"}, "insert_bom_table")
    if guard is not None:
        return guard
    if bom_type not in {"top_level_only", "parts_only", "indented"}:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="bom_type must be top_level_only, parts_only or indented",
        )
    if view_name not in self._drawing_views:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {view_name!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
            ),
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "view": view_name,
            "bom_type": bom_type,
            "template": template_path,
            "row_count": 2,
            "table_box_mm": [0.0, 0.0, 60.0, 15.0],
            "moved_onto_sheet": False,
        },
    )

insert_component async

insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Mock inserting a component into the active assembly.

Records the component in self._components so repeated inserts accumulate and list_components reflects them.

Parameters:

Name	Type	Description	Default
file_path	str	Path to the part or sub-assembly to insert.	required
x	float	X position in millimetres. Defaults to 0.0.	0.0
y	float	Y position in millimetres. Defaults to 0.0.	0.0
z	float	Z position in millimetres. Defaults to 0.0.	0.0

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Mock inserting a component into the active assembly.

    Records the component in ``self._components`` so repeated inserts
    accumulate and ``list_components`` reflects them.

    Args:
        file_path (str): Path to the part or sub-assembly to insert.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    self._components.append(f"component-{len(self._components) + 1}")

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "component": self._components[-1],
            "file_path": file_path,
            "position": {"x": x, "y": y, "z": z},
            "components_before": len(self._components) - 1,
            "components_after": len(self._components),
        },
        execution_time=self._delays["model_operation"],
    )

insert_model_dimensions async

insert_model_dimensions(view_name: str | None = None, include_hole_wizard: bool = True) -> AdapterResult[dict[str, Any]]

Mock importing model dimensions: three per view, never twice.

Mirrors the live result shape (views, dimensions_added, unique_dimensions, skipped_pictorial_views, method, autodimension_status) and its refusals.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def insert_model_dimensions(
    self, view_name: str | None = None, include_hole_wizard: bool = True
) -> AdapterResult[dict[str, Any]]:
    """Mock importing model dimensions: three per view, never twice.

    Mirrors the live result shape (``views``, ``dimensions_added``,
    ``unique_dimensions``, ``skipped_pictorial_views``, ``method``,
    ``autodimension_status``) and its refusals.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Drawing"}, "insert_model_dimensions")
    if guard is not None:
        return guard
    names = [view_name] if view_name else list(self._drawing_views)
    unknown = [n for n in names if n not in self._drawing_views]
    if unknown or not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"No view named {unknown[0]!r}. Views: "
                f"{', '.join(self._drawing_views) or 'none'}"
                if unknown
                else "No drawing views found to dimension; add views with "
                "create_technical_drawing or create_drawing_view"
            ),
        )
    if not hasattr(self, "_view_dimensions"):
        self._view_dimensions: dict[str, int] = {}
    per_view = []
    for name in names:
        before = self._view_dimensions.get(name, 0)
        after = before or 3
        self._view_dimensions[name] = after
        per_view.append(
            {
                "view": name,
                "dimensions_before": before,
                "dimensions_after": after,
                "dimensions_added": after - before,
                "duplicates_removed": 0,
            }
        )
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "views": per_view,
            "dimensions_added": sum(v["dimensions_added"] for v in per_view),
            "unique_dimensions": sum(self._view_dimensions.values()),
            "skipped_pictorial_views": [],
            "method": "insert_model_annotations",
            "autodimension_status": None,
        },
    )

is_connected

is_connected() -> bool

Check if mock connection is active.

Returns:

Name	Type	Description
bool	bool	True if connected, otherwise False.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def is_connected(self) -> bool:
    """Check if mock connection is active.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self._connected

list_available_materials async

list_available_materials(search: str | None = None) -> AdapterResult[list[dict[str, str]]]

Mock listing the material library, with the live metadata.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_available_materials(
    self, search: str | None = None
) -> AdapterResult[list[dict[str, str]]]:
    """Mock listing the material library, with the live ``metadata``."""
    needle = (search or "").strip().lower()
    items = [
        dict(m)
        for m in self._MOCK_MATERIALS
        if not needle
        or needle in m["name"].lower()
        or needle in m["classification"].lower()
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=items,
        metadata={
            "folders": [self._MOCK_MATERIAL_FOLDER],
            "total": len(self._MOCK_MATERIALS),
        },
    )

list_components async

list_components() -> AdapterResult[list[str]]

Mock listing the top-level components of the active assembly.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_components(self) -> AdapterResult[list[str]]:
    """Mock listing the top-level components of the active assembly.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=list(self._components),
        execution_time=self._delays["model_operation"] / 2,
    )

list_configurations async

list_configurations() -> AdapterResult[list[str]]

Mock configuration listing for the active model.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_configurations(self) -> AdapterResult[list[str]]:
    """Mock configuration listing for the active model.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    active = self._current_model.configuration or "Default"
    configs = [active] if active == "Default" else ["Default", active]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=configs,
        execution_time=self._delays["model_operation"] / 2,
    )

list_drawing_views async

list_drawing_views() -> AdapterResult[list[str]]

Mock listing the views on the active drawing.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_drawing_views(self) -> AdapterResult[list[str]]:
    """Mock listing the views on the active drawing.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"] / 2)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=list(self._drawing_views),
        execution_time=self._delays["model_operation"] / 2,
    )

list_features async

list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

Mock feature tree listing for the active model.

For an Assembly model, flattens in every configured component's features (see _assembly_components) alongside the document's own features, tagged with component/component_path the same way the real adapter does. Falls back to a small canned two-component fixture (plus one nested sub-assembly) when no components have been configured, mirroring the existing "seed realistic feature names" behavior for an empty Part.

Parameters:

Name	Type	Description	Default
include_suppressed	bool	The include suppressed value. Defaults to False.	False
max_assembly_depth	int	Sub-assembly recursion budget. Ignored for non-Assembly models. Defaults to 2.	2

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock feature tree listing for the active model.

    For an Assembly model, flattens in every configured component's
    features (see ``_assembly_components``) alongside the document's own
    features, tagged with ``component``/``component_path`` the same way
    the real adapter does. Falls back to a small canned two-component
    fixture (plus one nested sub-assembly) when no components have been
    configured, mirroring the existing "seed realistic feature names"
    behavior for an empty Part.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
        max_assembly_depth (int): Sub-assembly recursion budget. Ignored
            for non-Assembly models. Defaults to 2.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )

    await asyncio.sleep(self._delays["feature_operation"] / 2)
    self._operation_count += 1

    is_assembly = self._current_model.type == "Assembly"

    # Seed realistic feature names for empty mock state.
    if not self._features:
        seeded: list[dict[str, Any]] = [
            {
                "name": "Origin",
                "type": "OriginProfileFeature",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Front Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Right Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Top Plane",
                "type": "RefPlane",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
            {
                "name": "Sketch1",
                "type": "ProfileFeature",
                "suppressed": False,
                "component": None,
                "component_path": None,
                "component_parent": None,
            },
        ]
        if is_assembly:
            components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
            seeded.extend(
                self._flatten_assembly_components(
                    components, include_suppressed, max_assembly_depth - 1, None
                )
            )
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data=seeded,
            execution_time=self._delays["feature_operation"] / 2,
        )

    feature_rows: list[dict[str, Any]] = []
    for i, feature in enumerate(self._features.values()):
        row = {
            "name": feature.name,
            "type": feature.type,
            "suppressed": bool((feature.properties or {}).get("suppressed", False)),
            "position": i,
            "component": None,
            "component_path": None,
            "component_parent": None,
        }
        if include_suppressed or not row["suppressed"]:
            feature_rows.append(row)

    if is_assembly:
        components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
        feature_rows.extend(
            self._flatten_assembly_components(
                components,
                include_suppressed,
                max_assembly_depth - 1,
                None,
            )
        )

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature_rows,
        execution_time=self._delays["feature_operation"] / 2,
    )

list_model_dimensions async

list_model_dimensions(feature_name: str | None = None) -> AdapterResult[list[dict[str, Any]]]

Mock listing model dimensions from the tracked dimension table.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_model_dimensions(
    self, feature_name: str | None = None
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock listing model dimensions from the tracked dimension table."""
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Part", "Assembly"}, "list_model_dimensions")
    if guard is not None:
        return guard
    self._operation_count += 1
    dims = []
    for full_name, value in self._dimensions.items():
        feature = full_name.split("@", 1)[1] if "@" in full_name else ""
        if feature_name and feature.lower() != feature_name.lower():
            continue
        dims.append(
            {
                "full_name": full_name,
                "feature": feature,
                "value": value,
                "system_value": value / 1000.0,
                "read_only": False,
            }
        )
    if feature_name and not dims:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No dimensions found on feature {feature_name!r}",
        )
    return AdapterResult(status=AdapterResultStatus.SUCCESS, data=dims)

list_open_documents async

list_open_documents() -> AdapterResult[list[dict[str, Any]]]

Mock enumerating the currently open documents.

Returns every model the mock has created or opened this session, with is_active reflecting self._current_model.

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: The result produced by the
AdapterResult[list[dict[str, Any]]]	operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
    """Mock enumerating the currently open documents.

    Returns every model the mock has created or opened this session, with
    ``is_active`` reflecting ``self._current_model``.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the
        operation.
    """
    await asyncio.sleep(0.05)
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    active_path = (
        self._current_model.path if self._current_model is not None else None
    )
    docs = [
        {
            "title": model.name,
            "path": model.path,
            "type": model.type,
            "is_active": model.path == active_path,
        }
        for model in self._models.values()
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS, data=docs, execution_time=0.05
    )

measure_entities async

measure_entities(entities: list[str]) -> AdapterResult[dict[str, Any]]

Mock measuring: nominal values with the live adapter's validation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def measure_entities(
    self, entities: list[str]
) -> AdapterResult[dict[str, Any]]:
    """Mock measuring: nominal values with the live adapter's validation."""
    await asyncio.sleep(self._delays["model_operation"] / 2)
    guard = self._mock_doc_error({"Part", "Assembly"}, "measure_entities")
    if guard is not None:
        return guard
    if not entities or len(entities) > 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="measure_entities takes one or two entity specs",
        )
    self._operation_count += 1
    data: dict[str, Any] = {"selected": list(entities)}
    if len(entities) == 1:
        data.update({"area_m2": 0.0025, "perimeter_m": 0.2})
    else:
        data.update({"distance_m": 0.05, "angle_rad": 0.0, "is_parallel": True})
    return AdapterResult(status=AdapterResultStatus.SUCCESS, data=data)

mirror_feature async

mirror_feature(features: list[str], mirror_plane: str, merge: bool = True, mirror_bodies: bool = True) -> AdapterResult[dict[str, Any]]

Mock mirroring solid bodies or features about a plane.

The mock has no geometry engine, so it cannot measure a real volume change - it mirrors the live adapter's refusals instead of fabricating a result it cannot know. An empty source list or plane name is rejected outright (matching _mirror_feature_impl in solidworks/features.py verbatim), and a source or plane name that was never created in this session is rejected the same way _select_named_feature / _select_reference_entity would fail to select it there.

On success, the tracked self._mirror_volume figure (seeded at the live-measured 1819569.1 mm^3 wing volume) is doubled, matching the ~2.0 ratio a correct mirror produces (measured live: 1.998528 for a lofted wing, exactly 2.0 for a boss whose sketch sits on the plane).

Parameters:

Name	Type	Description	Default
features	list[str]	Body or feature names to mirror.	required
mirror_plane	str	Plane name to mirror about.	required
merge	bool	Merge the mirrored result with the original. Defaults to True.	True
mirror_bodies	bool	Mirror whole bodies rather than features. Defaults to True.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The mirror feature's name, inputs
AdapterResult[dict[str, Any]]	and volume before/after, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def mirror_feature(
    self,
    features: list[str],
    mirror_plane: str,
    merge: bool = True,
    mirror_bodies: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock mirroring solid bodies or features about a plane.

    The mock has no geometry engine, so it cannot measure a real volume
    change - it mirrors the live adapter's refusals instead of
    fabricating a result it cannot know. An empty source list or plane
    name is rejected outright (matching ``_mirror_feature_impl`` in
    ``solidworks/features.py`` verbatim), and a source or plane name
    that was never created in this session is rejected the same way
    ``_select_named_feature`` / ``_select_reference_entity`` would fail
    to select it there.

    On success, the tracked ``self._mirror_volume`` figure (seeded at
    the live-measured 1819569.1 mm^3 wing volume) is doubled, matching
    the ~2.0 ratio a correct mirror produces (measured live: 1.998528
    for a lofted wing, exactly 2.0 for a boss whose sketch sits on the
    plane).

    Args:
        features (list[str]): Body or feature names to mirror.
        mirror_plane (str): Plane name to mirror about.
        merge (bool): Merge the mirrored result with the original. Defaults to True.
        mirror_bodies (bool): Mirror whole bodies rather than features. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: The mirror feature's name, inputs
        and volume before/after, or error.
    """
    names = [n for n in (features or []) if n]
    if not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="mirror_feature requires at least one body or feature name",
        )
    if not mirror_plane:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="mirror_feature requires a mirror plane name",
        )

    known_sources = {feature.name for feature in self._features.values()} | set(
        self._components
    )
    for name in names:
        if name not in known_sources:
            kind = "body" if mirror_bodies else "feature"
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=f"Failed to select {kind} to mirror: {name}",
            )

    known_planes = self._BUILTIN_PLANES | set(self._reference_planes)
    if mirror_plane not in known_planes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Failed to select mirror plane: {mirror_plane}",
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    volume_before = self._mirror_volume
    volume_after = volume_before * 2
    self._mirror_volume = volume_after

    self._feature_tree_count += 1
    feature_name = f"Mirror{self._feature_tree_count}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": feature_name,
            "mirrored": names,
            "mirror_plane": mirror_plane,
            "merge": bool(merge),
            "mirror_bodies": bool(mirror_bodies),
            "volume_before": volume_before,
            "volume_after": volume_after,
            "volume_change": volume_after - volume_before,
            "volume_ratio": round(volume_after / volume_before, 6),
        },
        execution_time=self._delays["feature_operation"],
    )

open_model async

open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Mock opening a SolidWorks model.

Parameters:

Name	Type	Description	Default
file_path	str	Path to the target file.	required

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Raises:

Type	Description
SolidWorksOperationError	Simulated adapter failure.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Mock opening a SolidWorks model.

    Args:
        file_path (str): Path to the target file.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.

    Raises:
        SolidWorksOperationError: Simulated adapter failure.
    """
    if not self._connected:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
        )

    if self._simulate_errors:
        raise SolidWorksOperationError("Simulated adapter failure")

    await asyncio.sleep(self._delays["model_operation"])
    self._operation_count += 1

    # Determine model type from file extension
    file_path_lower = file_path.lower()
    if file_path_lower.endswith(".sldprt"):
        model_type = "Part"
    elif file_path_lower.endswith(".sldasm"):
        model_type = "Assembly"
    elif file_path_lower.endswith(".slddrw"):
        model_type = "Drawing"
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Unsupported file type: {file_path}",
        )

    # Create mock model
    model_name = file_path.split("/")[-1].split("\\")[-1]
    model = SolidWorksModel(
        path=file_path,
        name=model_name,
        type=model_type,
        is_active=True,
        configuration="Default",
        properties={
            "created": datetime.now().isoformat(),
            "model_id": model_name or f"Part{len(self._models) + 1}",
            "file_size": random.randint(100000, 5000000),
        },
    )

    self._current_model = model
    self._models[file_path] = model

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )

pack_and_go_assembly async

pack_and_go_assembly(source_path: str, target_dir: str) -> AdapterResult[dict]

Mock Pack-and-Go: simulate copying an assembly to a target directory.

Parameters:

Name	Type	Description	Default
source_path	str	Path to the source .sldasm file.	required
target_dir	str	Directory to copy files into.	required

Returns:

Type	Description
AdapterResult[dict]	AdapterResult[dict]: Simulated pack-and-go result.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def pack_and_go_assembly(
    self,
    source_path: str,
    target_dir: str,
) -> AdapterResult[dict]:
    """Mock Pack-and-Go: simulate copying an assembly to a target directory.

    Args:
        source_path (str): Path to the source .sldasm file.
        target_dir (str): Directory to copy files into.

    Returns:
        AdapterResult[dict]: Simulated pack-and-go result.
    """
    import pathlib

    await asyncio.sleep(0.05)
    self._operation_count += 1

    source = pathlib.Path(source_path)
    out_dir = pathlib.Path(target_dir)
    mock_parts = [f"MockPart{i}.SLDPRT" for i in range(1, 3)]
    source_files = [str(source)] + [str(source.parent / p) for p in mock_parts]
    copied_files = [str(out_dir / source.name)] + [
        str(out_dir / p) for p in mock_parts
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "source_assembly": str(source),
            "target_dir": str(out_dir),
            "copied_files": copied_files,
            "source_files": source_files,
            "unsaved_changes": [],
        },
        execution_time=0.05,
        metadata={"mock": True},
    )

pattern_circular async

pattern_circular(features: list[str], axis: str, count: int, angle: float = 360.0, equal_spacing: bool = True) -> AdapterResult[dict[str, Any]]

Mock patterning features around an axis.

The mock has no geometry engine, so it cannot measure a real volume change - it mirrors the live adapter's refusals instead of fabricating a result it cannot know (matching _pattern_circular_impl in solidworks/features.py verbatim for the three argument checks below). An axis name that was never created via create_axis in this session is rejected the same way SelectByID2 would fail to select it there.

On success, the tracked self._pattern_volume figure (seeded at the live-measured 48431.5 mm^3 hub+blade volume) grows by _PATTERN_BLADE_VOLUME * (count - 1), the live-derived per-instance volume, so volume_before/volume_after/volume_ratio stay self-consistent and scale with count roughly the way adding more blades to the hub would - reproducing the live 48431.5 -> 75916.4 mm^3 measurement exactly for count=4.

Parameters:

Name	Type	Description	Default
features	list[str]	Names of the features to pattern.	required
axis	str	Name of the axis to rotate about.	required
count	int	Total number of instances including the original.	required
angle	float	Total angle in degrees to spread them over. Defaults to 360.0.	360.0
equal_spacing	bool	Space instances evenly across angle. Defaults to True.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The pattern's name, inputs and
AdapterResult[dict[str, Any]]	volume before/after, or error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def pattern_circular(
    self,
    features: list[str],
    axis: str,
    count: int,
    angle: float = 360.0,
    equal_spacing: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mock patterning features around an axis.

    The mock has no geometry engine, so it cannot measure a real volume
    change - it mirrors the live adapter's refusals instead of
    fabricating a result it cannot know (matching
    ``_pattern_circular_impl`` in ``solidworks/features.py`` verbatim
    for the three argument checks below). An axis name that was never
    created via ``create_axis`` in this session is rejected the same
    way ``SelectByID2`` would fail to select it there.

    On success, the tracked ``self._pattern_volume`` figure (seeded at
    the live-measured 48431.5 mm^3 hub+blade volume) grows by
    ``_PATTERN_BLADE_VOLUME * (count - 1)``, the live-derived
    per-instance volume, so volume_before/volume_after/volume_ratio
    stay self-consistent and scale with ``count`` roughly the way
    adding more blades to the hub would - reproducing the live
    48431.5 -> 75916.4 mm^3 measurement exactly for ``count=4``.

    Args:
        features (list[str]): Names of the features to pattern.
        axis (str): Name of the axis to rotate about.
        count (int): Total number of instances including the original.
        angle (float): Total angle in degrees to spread them over. Defaults to 360.0.
        equal_spacing (bool): Space instances evenly across ``angle``. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: The pattern's name, inputs and
        volume before/after, or error.
    """
    names = [n for n in (features or []) if n]
    if not names:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="pattern_circular requires at least one feature name",
        )
    if not axis:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="pattern_circular requires an axis name to rotate about",
        )
    if int(count) < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"pattern_circular needs a count of at least 2 (got {count}); "
                "a pattern of one is just the original feature"
            ),
        )

    known_axes = set(self._axes)
    if axis not in known_axes:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Failed to select axis '{axis}'. Create one with "
                "create_axis first, and pass the name it returns."
            ),
        )

    await asyncio.sleep(self._delays["feature_operation"])
    self._operation_count += 1

    volume_before = self._pattern_volume
    volume_after = volume_before + self._PATTERN_BLADE_VOLUME * (int(count) - 1)
    self._pattern_volume = volume_after

    self._feature_tree_count += 1
    pattern_name = f"CirPattern{self._feature_tree_count}"

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": pattern_name,
            "patterned": names,
            "axis": axis,
            "count": int(count),
            "angle": float(angle),
            "equal_spacing": bool(equal_spacing),
            "volume_before": volume_before,
            "volume_after": volume_after,
            "volume_change": volume_after - volume_before,
            "volume_ratio": round(volume_after / volume_before, 6),
        },
        execution_time=self._delays["feature_operation"],
    )

rebuild_model async

rebuild_model(top_level_only: bool = False) -> AdapterResult[dict[str, Any]]

Mock rebuild with the real adapter's diagnostics contract.

Clean by default; issues placed in injected_rebuild_issues are explained with the same rebuild_diagnostics logic the real adapter uses, so ERROR-with-data / warnings-only behave identically.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def rebuild_model(
    self, top_level_only: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Mock rebuild with the real adapter's diagnostics contract.

    Clean by default; issues placed in ``injected_rebuild_issues`` are
    explained with the same ``rebuild_diagnostics`` logic the real
    adapter uses, so ERROR-with-data / warnings-only behave identically.
    """
    from .solidworks.rebuild_diagnostics import explain, summarize

    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    await asyncio.sleep(self._delays["model_operation"] / 4)
    entries = [explain(i) for i in self.injected_rebuild_issues]
    error_count, warning_count, summary = summarize(entries)
    data = {
        "rebuilt": True,
        "top_level_only": top_level_only,
        "errors": entries,
        "error_count": error_count,
        "warning_count": warning_count,
        "summary": summary,
    }
    return AdapterResult(
        status=(
            AdapterResultStatus.ERROR
            if error_count
            else AdapterResultStatus.SUCCESS
        ),
        data=data,
        error=summary if error_count else None,
        execution_time=self._delays["model_operation"] / 4,
    )

rename_feature async

rename_feature(old_name: str, new_name: str) -> AdapterResult[dict[str, Any]]

Mock renaming a named feature in the active model.

Mirrors the real adapter: an empty target name, an unknown feature, or a target name already in use are all errors; renaming to the current name is a no-op success.

Parameters:

Name	Type	Description	Default
old_name	str	Current feature name.	required
new_name	str	New feature name.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def rename_feature(
    self, old_name: str, new_name: str
) -> AdapterResult[dict[str, Any]]:
    """Mock renaming a named feature in the active model.

    Mirrors the real adapter: an empty target name, an unknown feature, or
    a target name already in use are all errors; renaming to the current
    name is a no-op success.

    Args:
        old_name (str): Current feature name.
        new_name (str): New feature name.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    new = new_name.split("@", 1)[0].strip()
    if not new:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="new_name must not be empty"
        )

    if old_name in self._sketches and new != old_name:
        return self._mock_rename_sketch(old_name, new)
    key = next((k for k, f in self._features.items() if f.name == old_name), None)
    if key is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Feature not found: {old_name}",
        )
    if new == old_name:
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data={
                "renamed": False,
                "old_name": old_name,
                "new_name": new,
                "reason": "old and new names are the same",
            },
            execution_time=self._delays["model_operation"],
        )
    if any(f.name == new for f in self._features.values()):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Cannot rename to '{new}': a feature with that name already exists"
            ),
        )

    self._features[key].name = new
    if old_name in self._suppressed_features:
        self._suppressed_features.discard(old_name)
        self._suppressed_features.add(new)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"renamed": True, "old_name": old_name, "new_name": new},
        execution_time=self._delays["model_operation"],
    )

save_body_as_part async

save_body_as_part(body_name: str, file_path: str) -> AdapterResult[dict[str, Any]]

Mock extracting a solid body from the active part to a new file.

The mock has no bodies, so it cannot validate body_name against real geometry - it mirrors the live adapter's other refusals (no model, not a part, blank arguments, missing parent directory) and, on a valid request, writes an empty placeholder file so callers and tests can observe the side effect.

Parameters:

Name	Type	Description	Default
body_name	str	Name of a solid body in the active part.	required
file_path	str	Absolute path for the new .sldprt.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The body, the written path, and a
AdapterResult[dict[str, Any]]	single-element body list, or an error.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def save_body_as_part(
    self, body_name: str, file_path: str
) -> AdapterResult[dict[str, Any]]:
    """Mock extracting a solid body from the active part to a new file.

    The mock has no bodies, so it cannot validate ``body_name`` against
    real geometry - it mirrors the live adapter's other refusals (no
    model, not a part, blank arguments, missing parent directory) and, on
    a valid request, writes an empty placeholder file so callers and
    tests can observe the side effect.

    Args:
        body_name (str): Name of a solid body in the active part.
        file_path (str): Absolute path for the new ``.sldprt``.

    Returns:
        AdapterResult[dict[str, Any]]: The body, the written path, and a
        single-element body list, or an error.
    """
    import os as _os

    await asyncio.sleep(self._delays["model_operation"])

    model = self._current_model
    if model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if getattr(model, "type", None) != "Part":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="save_body_as_part requires an active part document",
        )
    if not str(body_name or "").strip():
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="body_name is required"
        )
    target = str(file_path or "").strip()
    if not target:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="file_path is required"
        )
    target = _os.path.abspath(target)
    parent = _os.path.dirname(target)
    if not _os.path.isdir(parent):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Parent directory does not exist: {parent}",
        )

    with open(target, "w", encoding="utf-8"):
        pass
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "body": body_name,
            "file_path": target,
            "feature": f"Save Bodies{self._operation_count}",
            "solid_bodies": [body_name],
        },
        execution_time=self._delays["model_operation"],
    )

save_file async

save_file(file_path: str | None = None) -> AdapterResult[dict[str, Any]]

Legacy compatibility save operation for tests.

Parameters:

Name	Type	Description	Default
file_path	str | None	Path to the target file. Defaults to None.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def save_file(
    self, file_path: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Legacy compatibility save operation for tests.

    Args:
        file_path (str | None): Path to the target file. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(0.02)
    self._operation_count += 1
    resolved_path = file_path or self._current_model.path
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"file_path": resolved_path, "saved": True},
        execution_time=0.02,
    )

select_face_edges async

select_face_edges(point: list[float] | None = None, side: str | None = None, plane: str | None = None, edge_type: str = 'all', append: bool = False) -> AdapterResult[dict[str, Any]]

Mock face-edge multi-selection on a canned 10 mm block.

Mirrors the real adapter's contract: the same input validation, the same payload shape, and the same failure cases. The block spans 0..10 mm on every axis; the +Z/-Z faces carry a 2 mm radius hole rim once any circle has been sketched, so edge_type="circular" behaves like a real drilled part. Front Plane (z = 0) is the only reference plane with a face on it.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def select_face_edges(
    self,
    point: list[float] | None = None,
    side: str | None = None,
    plane: str | None = None,
    edge_type: str = "all",
    append: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Mock face-edge multi-selection on a canned 10 mm block.

    Mirrors the real adapter's contract: the same input validation, the
    same payload shape, and the same failure cases. The block spans
    0..10 mm on every axis; the +Z/-Z faces carry a 2 mm radius hole rim
    once any circle has been sketched, so ``edge_type="circular"``
    behaves like a real drilled part. ``Front Plane`` (z = 0) is the only
    reference plane with a face on it.
    """
    from .solidworks.face_selection import side_vector, validate_face_query

    problem = validate_face_query(point, side, plane, edge_type)
    if problem:
        return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if getattr(self._current_model, "type", "Part") != "Part":
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="select_face_edges requires an active part document.",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)

    if point is not None:
        normal = self._mock_face_at(point)
        if normal is None:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=f"No face found at point {list(point)} mm.",
            )
    elif side is not None:
        normal = side_vector(side)
    elif plane == "Front Plane":
        normal = (0.0, 0.0, -1.0)
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"No body face lies on {plane!r}.",
        )

    center = [5.0 + 5.0 * c for c in normal]
    has_hole = any(e.startswith("Circle") for e in self._sketch_entity_ids)
    edges: list[dict[str, Any]] = [
        {"curve": "linear", "length_mm": 10.0, "face_index": 0} for _ in range(4)
    ]
    if has_hole and normal[2] != 0:
        edges.append(
            {
                "curve": "circular",
                "center_mm": [5.0, 5.0, center[2]],
                "axis": [0.0, 0.0, 1.0],
                "radius_mm": 2.0,
                "face_index": 0,
            }
        )
    edges = [e for e in edges if edge_type == "all" or e["curve"] == edge_type]
    if not edges:
        kind = "" if edge_type == "all" else f"{edge_type} "
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"The selected face has no {kind}edges (face centre {center} mm).",
        )

    if not append:
        self._selection.clear()
    self._selection.extend(f"Edge{i}" for i in range(len(edges)))
    face = {
        "index": 0,
        "center_mm": center,
        "normal": [float(c) for c in normal],
        "area_mm2": 100.0,
        "planar": True,
    }
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "face": face,
            "faces": [face],
            "edge_type": edge_type,
            "edges": edges,
            "selected_edges": len(edges),
            "selection_count": len(self._selection),
        },
        execution_time=self._delays["feature_operation"] / 4,
    )

select_feature async

select_feature(feature_name: str, append: bool = False) -> AdapterResult[dict[str, Any]]

Mock feature selection, mirroring the real adapter's contract.

Succeeds only for names the mock is tracking for the active model (created features, sketches, default planes); anything else is an ERROR naming the feature - never SUCCESS with selected: False.

Parameters:

Name	Type	Description	Default
feature_name	str	The feature name, optionally @doc qualified.	required
append	bool	Add to the current selection. Defaults to False.	False

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def select_feature(
    self, feature_name: str, append: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Mock feature selection, mirroring the real adapter's contract.

    Succeeds only for names the mock is tracking for the active model
    (created features, sketches, default planes); anything else is an
    ERROR naming the feature - never SUCCESS with ``selected: False``.

    Args:
        feature_name (str): The feature name, optionally ``@doc`` qualified.
        append (bool): Add to the current selection. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    if not self._current_model:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="No active model",
        )
    await asyncio.sleep(self._delays["feature_operation"] / 4)
    self._operation_count += 1

    bare = feature_name.split("@", 1)[0].strip()
    known = (
        {f.name for f in self._features.values()}
        | set(self._sketches)
        | set(self._DEFAULT_SELECTABLE)
    )
    if bare not in known:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Feature not found or could not be selected: {feature_name}",
        )
    if not append:
        self._selection.clear()
    if bare not in self._selection:
        self._selection.append(bare)
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "selected": True,
            "feature_name": feature_name,
            "selected_name": bare,
            "entity_type": "mock",
            "selection_count": len(self._selection),
        },
        execution_time=self._delays["feature_operation"] / 4,
    )

set_component_state async

set_component_state(component: str, fixed: bool | None = None, flexible: bool | None = None) -> AdapterResult[dict[str, Any]]

Mock fixing, floating and flexing a component.

Tracks each component's state on self._component_states.

Parameters:

Name	Type	Description	Default
component	str	Instance name.	required
fixed	bool | None	True fixes it, False floats it.	None
flexible	bool | None	True flexible, False rigid.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The state before and after.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_component_state(
    self,
    component: str,
    fixed: bool | None = None,
    flexible: bool | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock fixing, floating and flexing a component.

    Tracks each component's state on ``self._component_states``.

    Args:
        component (str): Instance name.
        fixed (bool | None): True fixes it, False floats it.
        flexible (bool | None): True flexible, False rigid.

    Returns:
        AdapterResult[dict[str, Any]]: The state before and after.
    """
    if fixed is None and flexible is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="Nothing to change: give fixed, flexible or both.",
        )
    states = self._component_states
    before = dict(states.get(component, {"fixed": False, "flexible": False}))
    after = dict(before)
    if fixed is not None:
        after["fixed"] = fixed
    if flexible is not None:
        after["flexible"] = flexible
    states[component] = after
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"component": component, "before": before, "after": after},
    )

set_custom_property async

set_custom_property(name: str, value: str, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock writing one custom property.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_custom_property(
    self, name: str, value: str, configuration: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Mock writing one custom property."""
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if not name.strip():
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="name is required"
        )
    if not hasattr(self, "_custom_properties"):
        self._custom_properties: dict[tuple[str, str], dict[str, str]] = {}
    key = (self._mock_doc_key(), configuration or "")
    self._custom_properties.setdefault(key, {})[name] = str(value)
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "name": name,
            "value": str(value),
            "resolved": str(value),
            "configuration": configuration or "",
        },
    )

set_dimension async

set_dimension(name: str, value: float) -> AdapterResult[None]

Mock setting a dimension value.

Parameters:

Name	Type	Description	Default
name	str	The name value.	required
value	float	The value value.	required

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Mock setting a dimension value.

    Args:
        name (str): The name value.
        value (float): The value value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    await asyncio.sleep(0.1)  # Fast operation
    self._operation_count += 1

    self._dimensions[name] = value

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS, data=None, execution_time=0.1
    )

set_material async

set_material(material_name: str, database: str | None = None, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Mock assigning a material; unknown names fail as they do live.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_material(
    self,
    material_name: str,
    database: str | None = None,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mock assigning a material; unknown names fail as they do live."""
    guard = self._mock_doc_error({"Part"}, "set_material")
    if guard is not None:
        return guard
    wanted = material_name.strip().lower()
    match = next(
        (m for m in self._MOCK_MATERIALS if m["name"].lower() == wanted), None
    )
    if match is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Material {material_name!r} not found in "
                f"{database or 'SOLIDWORKS Materials'!r}; use "
                "list_available_materials for the exact name and library."
            ),
        )
    if not hasattr(self, "_materials"):
        self._materials: dict[str, dict[str, str]] = {}
    self._materials[self._mock_doc_key()] = match
    self._operation_count += 1
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "material": match["name"],
            "database": database or "SOLIDWORKS Materials",
            "configuration": configuration,
        },
    )

set_sheet_scale async

set_sheet_scale(numerator: float, denominator: float) -> AdapterResult[dict[str, Any]]

Mock setting the sheet scale.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_sheet_scale(
    self, numerator: float, denominator: float
) -> AdapterResult[dict[str, Any]]:
    """Mock setting the sheet scale."""
    guard = self._mock_doc_error({"Drawing"}, "set_sheet_scale")
    if guard is not None:
        return guard
    if numerator <= 0 or denominator <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="Scale values must be positive"
        )
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "sheet": "Sheet1",
            "scale": f"{numerator:g}:{denominator:g}",
            "requested": f"{numerator:g}:{denominator:g}",
        },
    )

set_units async

set_units(unit_system: str) -> AdapterResult[dict[str, Any]]

Mock setting the active document's linear unit system.

Mirrors the real adapter: an unrecognised token is an error, and the applied token is recorded on the current model's properties.

Parameters:

Name	Type	Description	Default
unit_system	str	One of mm, cm, m, in, ft (aliases such as inch / millimeters accepted).	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
    """Mock setting the active document's linear unit system.

    Mirrors the real adapter: an unrecognised token is an error, and the
    applied token is recorded on the current model's ``properties``.

    Args:
        unit_system (str): One of ``mm``, ``cm``, ``m``, ``in``, ``ft``
            (aliases such as ``inch`` / ``millimeters`` accepted).

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(0.1)

    token = _normalise_mock_unit_system(unit_system)
    if token is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unrecognised unit system {unit_system!r}. "
                "Expected one of: mm, cm, m, in, ft."
            ),
        )
    if self._current_model is None:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    self._operation_count += 1
    props = dict(self._current_model.properties or {})
    props["units"] = token
    self._current_model.properties = props

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={"unit_system": token, "verified": True},
        execution_time=0.1,
    )

sketch_circular_pattern async

sketch_circular_pattern(entities: list[str], angle: float, count: int) -> AdapterResult[str]

Mock creating a circular sketch pattern around the sketch origin.

Parameters:

Name	Type	Description	Default
entities	list[str]	Seed entity IDs.	required
angle	float	Total swept angle in degrees.	required
count	int	Total number of instances (including the seed).	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_circular_pattern(
    self,
    entities: list[str],
    angle: float,
    count: int,
) -> AdapterResult[str]:
    """Mock creating a circular sketch pattern around the sketch origin.

    Args:
        entities (list[str]): Seed entity IDs.
        angle (float): Total swept angle in degrees.
        count (int): Total number of instances (including the seed).

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires at least one entity",
        )
    if count < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires count >= 2",
        )
    if angle <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_circular_pattern requires angle > 0",
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    pattern_id = f"CircularPattern_{count}x{angle}deg_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=pattern_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_linear_pattern async

sketch_linear_pattern(entities: list[str], direction_x: float, direction_y: float, spacing: float, count: int) -> AdapterResult[str]

Mock creating a linear sketch pattern.

Mirrors the real adapter's validation rules — empty entities, count < 2, non-positive spacing, and a zero direction vector each produce a clear error without "creating" a pattern.

Parameters:

Name	Type	Description	Default
entities	list[str]	Seed entity IDs.	required
direction_x	float	Pattern direction X component.	required
direction_y	float	Pattern direction Y component.	required
spacing	float	Distance between instances in millimetres.	required
count	int	Total number of instances (including the seed).	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_linear_pattern(
    self,
    entities: list[str],
    direction_x: float,
    direction_y: float,
    spacing: float,
    count: int,
) -> AdapterResult[str]:
    """Mock creating a linear sketch pattern.

    Mirrors the real adapter's validation rules — empty entities,
    count < 2, non-positive spacing, and a zero direction vector each
    produce a clear error without "creating" a pattern.

    Args:
        entities (list[str]): Seed entity IDs.
        direction_x (float): Pattern direction X component.
        direction_y (float): Pattern direction Y component.
        spacing (float): Distance between instances in millimetres.
        count (int): Total number of instances (including the seed).

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires at least one entity",
        )
    if count < 2:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires count >= 2",
        )
    if spacing <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_linear_pattern requires spacing > 0",
        )
    if math.hypot(direction_x, direction_y) < 1e-9:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=("sketch_linear_pattern requires a non-zero direction vector"),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    pattern_id = f"LinearPattern_{count}x{spacing}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=pattern_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_mirror async

sketch_mirror(entities: list[str], mirror_line: str) -> AdapterResult[str]

Mock mirroring sketch entities about a centerline.

Parameters:

Name	Type	Description	Default
entities	list[str]	IDs of segments to mirror.	required
mirror_line	str	ID of the centerline to mirror across.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_mirror(
    self, entities: list[str], mirror_line: str
) -> AdapterResult[str]:
    """Mock mirroring sketch entities about a centerline.

    Args:
        entities (list[str]): IDs of segments to mirror.
        mirror_line (str): ID of the centerline to mirror across.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_mirror requires at least one entity",
        )
    if not mirror_line:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "sketch_mirror requires a mirror_line entity ID (add_centerline)"
            ),
        )
    if mirror_line not in self._sketch_entity_ids:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown mirror_line entity '{mirror_line}'. Use the "
                "ID returned by add_centerline."
            ),
        )
    # Mirror the real adapter — IModelDoc2::SketchMirror needs a
    # centreline as the mirror axis; other segments silently no-op.
    if not mirror_line.startswith("Centerline_"):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"mirror_line must be a centerline (from add_centerline), "
                f"got '{mirror_line}'"
            ),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    mirror_id = f"Mirror_{mirror_line}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=mirror_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

sketch_offset async

sketch_offset(entities: list[str], offset_distance: float, reverse_direction: bool) -> AdapterResult[str]

Mock offsetting sketch entities by a fixed distance.

Parameters:

Name	Type	Description	Default
entities	list[str]	IDs of segments to offset.	required
offset_distance	float	Distance in millimetres. Must be > 0.	required
reverse_direction	bool	Flip the offset direction.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def sketch_offset(
    self,
    entities: list[str],
    offset_distance: float,
    reverse_direction: bool,
) -> AdapterResult[str]:
    """Mock offsetting sketch entities by a fixed distance.

    Args:
        entities (list[str]): IDs of segments to offset.
        offset_distance (float): Distance in millimetres. Must be > 0.
        reverse_direction (bool): Flip the offset direction.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    if not self._current_sketch:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active sketch"
        )
    if not entities:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error="sketch_offset requires at least one entity",
        )
    if offset_distance <= 0:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                "sketch_offset requires offset_distance > 0 — use "
                "reverse_direction to flip the side"
            ),
        )
    for ent in entities:
        if ent not in self._sketch_entity_ids:
            return AdapterResult(
                status=AdapterResultStatus.ERROR,
                error=(
                    f"Unknown sketch entity '{ent}'. Use IDs returned by "
                    "add_line/add_arc/add_circle/add_spline/add_centerline."
                ),
            )

    await asyncio.sleep(self._delays["sketch_operation"] / 2)
    self._operation_count += 1

    direction = "inward" if reverse_direction else "outward"
    offset_id = f"Offset_{offset_distance}_{direction}_{random.randint(1000, 9999)}"
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=offset_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )

suppress_feature async

suppress_feature(name: str, suppress: bool = True) -> AdapterResult[dict[str, Any]]

Mock suppressing or unsuppressing a named feature.

Parameters:

Name	Type	Description	Default
name	str	Feature name.	required
suppress	bool	True to suppress, False to unsuppress.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def suppress_feature(
    self, name: str, suppress: bool = True
) -> AdapterResult[dict[str, Any]]:
    """Mock suppressing or unsuppressing a named feature.

    Args:
        name (str): Feature name.
        suppress (bool): True to suppress, False to unsuppress.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])

    known = any(f.name == name for f in self._features.values())
    if not known:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error=f"Feature not found: {name}"
        )

    was = name in self._suppressed_features
    if suppress:
        self._suppressed_features.add(name)
    else:
        self._suppressed_features.discard(name)
    self._operation_count += 1

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "feature": name,
            "requested": suppress,
            "suppressed": bool(suppress),
            "was_suppressed": was,
        },
        execution_time=self._delays["model_operation"],
    )

undo async

undo(count: int = 1) -> AdapterResult[dict[str, Any]]

Mock undoing the last operations in the active model.

Removes the most recently added features, mirroring what an undo of feature-creation steps does to the tree. tree_changed is False when there was nothing left to undo, which is what the real adapter reports too - SolidWorks accepts an undo on an empty stack quietly.

Parameters:

Name	Type	Description	Default
count	int	Number of steps to undo.	1

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

async def undo(self, count: int = 1) -> AdapterResult[dict[str, Any]]:
    """Mock undoing the last operations in the active model.

    Removes the most recently added features, mirroring what an undo of
    feature-creation steps does to the tree. ``tree_changed`` is ``False``
    when there was nothing left to undo, which is what the real adapter
    reports too - SolidWorks accepts an undo on an empty stack quietly.

    Args:
        count (int): Number of steps to undo.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    await asyncio.sleep(self._delays["model_operation"])
    steps = max(1, int(count))

    keys = list(self._features)
    before = [self._features[k].name for k in keys]
    doomed = keys[-steps:] if steps <= len(keys) else list(keys)
    removed = [self._features[k].name for k in doomed]
    for key in doomed:
        self._suppressed_features.discard(self._features[key].name)
        del self._features[key]
    self._operation_count += 1
    after = [f.name for f in self._features.values()]

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "requested_steps": steps,
            "features_before": len(before),
            "features_after": len(after),
            "removed_features": removed,
            "tree_changed": before != after,
        },
        execution_time=self._delays["model_operation"],
    )

RevolveParameters

Bases: BaseModel

Parameters for revolve operations.

Attributes:

Name	Type	Description
angle	float	The angle value.
both_directions	bool	The both directions value.
merge_result	bool	The merge result value.
reverse_direction	bool	The reverse direction value.
thin_feature	bool	The thin feature value.
thin_thickness	float | None	The thin thickness value.
sketch_name	str | None	The sketch to revolve, by its tree name; None for the sketch closed last.
axis_entity	str | None	A reference axis to revolve about, by its tree name; None for the sketch's own centreline.

SolidWorksAdapter

SolidWorksAdapter(config: object | None = None)

Bases: ABC

Base adapter interface for SolidWorks integration.

Parameters:

Name	Type	Description	Default
config	object | None	Configuration values for the operation. Defaults to None.	None

Attributes:

Name	Type	Description
_metrics	Any	The metrics value.
config	Any	The config value.
config_dict	Any	The config dict value.

Initialize adapter with configuration.

Parameters:

Name	Type	Description	Default
config	object | None	Configuration values for the operation. Defaults to None.	None

Source code in src/solidworks_mcp/adapters/base.py

def __init__(self, config: object | None = None):
    """Initialize adapter with configuration.

    Args:
        config (object | None): Configuration values for the operation. Defaults to None.
    """
    if config is None:
        normalized_config: dict[str, Any] = {}
    elif isinstance(config, Mapping):
        normalized_config = dict(config)
    elif hasattr(config, "model_dump"):
        normalized_config = dict(config.model_dump())
    else:
        normalized_config = {}

    # Preserve original config object for compatibility with tests and
    # call sites that compare object identity/equality.
    self.config = config
    # Keep a normalized mapping for adapter internals.
    self.config_dict = normalized_config
    self._metrics = {
        "operations_count": 0,
        "errors_count": 0,
        "average_response_time": 0.0,
    }
    # SolidWorks-as-Code session logging. Set soc_session_id to enable
    # automatic ToolCallRecord writes for every adapter operation.
    self.soc_session_id: str | None = None
    self.soc_db_path: Path | None = None

Methods:

activate_document async

activate_document(title_or_path: str) -> AdapterResult[dict[str, Any]]

Make an already-open document the active one.

Parameters:

Name	Type	Description	Default
title_or_path	str	Title, full path, or file name of an open document.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: What was activated, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def activate_document(
    self, title_or_path: str
) -> AdapterResult[dict[str, Any]]:
    """Make an already-open document the active one.

    Args:
        title_or_path (str): Title, full path, or file name of an open
            document.

    Returns:
        AdapterResult[dict[str, Any]]: What was activated, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="activate_document is not implemented by this adapter",
    )

add_arc async

add_arc(center_x: float, center_y: float, start_x: float, start_y: float, end_x: float, end_y: float) -> AdapterResult[str]

Add an arc to the current sketch.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
start_x	float	The start x value.	required
start_y	float	The start y value.	required
end_x	float	The end x value.	required
end_y	float	The end y value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_arc(
    self,
    center_x: float,
    center_y: float,
    start_x: float,
    start_y: float,
    end_x: float,
    end_y: float,
) -> AdapterResult[str]:
    """Add an arc to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        start_x (float): The start x value.
        start_y (float): The start y value.
        end_x (float): The end x value.
        end_y (float): The end y value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_arc is not implemented by this adapter",
    )

add_centerline async

add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a centerline to the current sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a centerline to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_centerline is not implemented by this adapter",
    )

add_chamfer async

add_chamfer(distance: float, edge_names: list[str], angle: float = 45.0, flip: bool = False) -> AdapterResult[Any]

Add an angle-distance chamfer to the named or selected edges.

At the default 45 degrees both legs equal distance.

Parameters:

Name	Type	Description	Default
distance	float	Chamfer distance in millimeters, along one face.	required
edge_names	list[str]	List of edge names to chamfer.	required
angle	float	Chamfer angle in degrees. Defaults to 45.	45.0
flip	bool	Measure distance along the other face.	False

Returns:

Name	Type	Description
AdapterResult	AdapterResult[Any]	Feature result or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_chamfer(
    self,
    distance: float,
    edge_names: list[str],
    angle: float = 45.0,
    flip: bool = False,
) -> AdapterResult[Any]:
    """Add an angle-distance chamfer to the named or selected edges.

    At the default 45 degrees both legs equal ``distance``.

    Args:
        distance (float): Chamfer distance in millimeters, along one face.
        edge_names (list[str]): List of edge names to chamfer.
        angle (float): Chamfer angle in degrees. Defaults to 45.
        flip (bool): Measure ``distance`` along the other face.

    Returns:
        AdapterResult: Feature result or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_chamfer is not implemented by this adapter",
    )

add_circle abstractmethod async

add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Add a circle to the current sketch.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
radius	float	The radius value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Add a circle to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_datum_tag async

add_datum_tag(label: str, attach_at_mm: tuple[float, float], x_mm: float, y_mm: float) -> AdapterResult[dict[str, Any]]

Add a datum feature symbol on a drawing edge.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def add_datum_tag(
    self,
    label: str,
    attach_at_mm: tuple[float, float],
    x_mm: float,
    y_mm: float,
) -> AdapterResult[dict[str, Any]]:
    """Add a datum feature symbol on a drawing edge.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_datum_tag is not implemented by this adapter",
    )

add_drawing_view async

add_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Add a view of a model to the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path, orientation, position in millimetres and optional view scale.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The new view's details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Add a view of a model to the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path, orientation,
            position in millimetres and optional view scale.

    Returns:
        AdapterResult[dict[str, Any]]: The new view's details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_drawing_view is not implemented by this adapter",
    )

add_ellipse async

add_ellipse(center_x: float, center_y: float, major_axis: float, minor_axis: float) -> AdapterResult[str]

Add an ellipse to the current sketch.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
major_axis	float	The major axis value.	required
minor_axis	float	The minor axis value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_ellipse(
    self,
    center_x: float,
    center_y: float,
    major_axis: float,
    minor_axis: float,
) -> AdapterResult[str]:
    """Add an ellipse to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        major_axis (float): The major axis value.
        minor_axis (float): The minor axis value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_ellipse is not implemented by this adapter",
    )

add_fillet async

add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[Any]

Add a fillet feature to selected edges.

Rounds the selected edges of the current solid body with the given radius.

Parameters:

Name	Type	Description	Default
radius	float	Fillet radius in millimeters.	required
edge_names	list[str]	List of edge names to fillet.	required

Returns:

Name	Type	Description
AdapterResult	AdapterResult[Any]	Feature result or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[Any]:
    """Add a fillet feature to selected edges.

    Rounds the selected edges of the current solid body with the given radius.

    Args:
        radius (float): Fillet radius in millimeters.
        edge_names (list[str]): List of edge names to fillet.

    Returns:
        AdapterResult: Feature result or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_fillet is not implemented by this adapter",
    )

add_gtol async

add_gtol(characteristic: str, tolerance: float, x_mm: float, y_mm: float, diameter_zone: bool = False, material_condition: str = 'none', datums: list[str] | None = None, attach_at_mm: tuple[float, float] | None = None, dimension: tuple[str, str] | None = None) -> AdapterResult[dict[str, Any]]

Add a GD&T feature control frame to the active drawing.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def add_gtol(
    self,
    characteristic: str,
    tolerance: float,
    x_mm: float,
    y_mm: float,
    diameter_zone: bool = False,
    material_condition: str = "none",
    datums: list[str] | None = None,
    attach_at_mm: tuple[float, float] | None = None,
    dimension: tuple[str, str] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Add a GD&T feature control frame to the active drawing.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_gtol is not implemented by this adapter",
    )

add_line abstractmethod async

add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a line to the current sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a line to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_mate async

add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0, face_a: list[float] | None = None, face_b: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Mate two components together in the active assembly.

Parameters:

Name	Type	Description	Default
component_a	str	First component instance name.	required
component_b	str	Second component instance name.	required
entity_a	str	Named feature on the first component. Defaults to "Front Plane".	'Front Plane'
entity_b	str	Named feature on the second component. Defaults to "Front Plane".	'Front Plane'
mate_type	str	Mate type, e.g. coincident. Defaults to "coincident".	'coincident'
alignment	str	aligned, anti_aligned or closest. Defaults to "aligned".	'aligned'
distance	float	Distance in millimetres, for a distance mate. Defaults to 0.0.	0.0
angle	float	Angle in degrees, for an angle mate. Defaults to 0.0.	0.0
face_a	list[float] | None	A point on a face of the first component, in its part coordinates (mm), used instead of entity_a.	None
face_b	list[float] | None	The same for the second component.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Mate details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
    face_a: list[float] | None = None,
    face_b: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Mate two components together in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type, e.g. ``coincident``. Defaults to
            "coincident".
        alignment (str): ``aligned``, ``anti_aligned`` or ``closest``.
            Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.
        face_a (list[float] | None): A point on a face of the first
            component, in its part coordinates (mm), used instead of
            ``entity_a``.
        face_b (list[float] | None): The same for the second component.

    Returns:
        AdapterResult[dict[str, Any]]: Mate details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_mate is not implemented by this adapter",
    )

add_note async

add_note(payload: Any = None) -> AdapterResult[dict[str, Any]]

Place a text note on the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the note text, its position in millimetres and an optional font size in points.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The note's details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
    """Place a text note on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the note text, its position in
            millimetres and an optional font size in points.

    Returns:
        AdapterResult[dict[str, Any]]: The note's details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_note is not implemented by this adapter",
    )

add_polygon async

add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Add a regular polygon to the current sketch.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
radius	float	The radius value.	required
sides	int	The sides value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_polygon(
    self, center_x: float, center_y: float, radius: float, sides: int
) -> AdapterResult[str]:
    """Add a regular polygon to the current sketch.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.
        sides (int): The sides value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_polygon is not implemented by this adapter",
    )

add_rectangle abstractmethod async

add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add a rectangle to the current sketch.

Parameters:

Name	Type	Description	Default
x1	float	The x1 value.	required
y1	float	The y1 value.	required
x2	float	The x2 value.	required
y2	float	The y2 value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a rectangle to the current sketch.

    Args:
        x1 (float): The x1 value.
        y1 (float): The y1 value.
        x2 (float): The x2 value.
        y2 (float): The y2 value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

add_sketch_circle async

add_sketch_circle(center_x: float, center_y: float, radius: float, construction: bool = False) -> AdapterResult[str]

Alias for add_circle used by some tool flows.

Parameters:

Name	Type	Description	Default
center_x	float	The center x value.	required
center_y	float	The center y value.	required
radius	float	The radius value.	required
construction	bool	The construction value. Defaults to False.	False

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_circle(
    self,
    center_x: float,
    center_y: float,
    radius: float,
    construction: bool = False,
) -> AdapterResult[str]:
    """Alias for add_circle used by some tool flows.

    Args:
        center_x (float): The center x value.
        center_y (float): The center y value.
        radius (float): The radius value.
        construction (bool): The construction value. Defaults to False.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self.add_circle(center_x, center_y, radius)

add_sketch_constraint async

add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Apply a geometric constraint between sketch entities.

Parameters:

Name	Type	Description	Default
entity1	str	The entity1 value.	required
entity2	str | None	The entity2 value.	required
relation_type	str	The relation type value.	required
entity3	str | None	Third entity ID — only used by the symmetric relation (the centerline of symmetry). All other relation types reject a non-null entity3.	None

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Apply a geometric constraint between sketch entities.

    Args:
        entity1 (str): The entity1 value.
        entity2 (str | None): The entity2 value.
        relation_type (str): The relation type value.
        entity3 (str | None): Third entity ID — only used by the
            ``symmetric`` relation (the centerline of symmetry). All
            other relation types reject a non-null ``entity3``.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_sketch_constraint is not implemented by this adapter",
    )

add_sketch_dimension async

add_sketch_dimension(entity1: str, entity2: str | None, dimension_type: str, value: float) -> AdapterResult[str]

Add a sketch dimension.

Parameters:

Name	Type	Description	Default
entity1	str	The entity1 value.	required
entity2	str | None	The entity2 value.	required
dimension_type	str	The dimension type value.	required
value	float	The value value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_sketch_dimension(
    self,
    entity1: str,
    entity2: str | None,
    dimension_type: str,
    value: float,
) -> AdapterResult[str]:
    """Add a sketch dimension.

    Args:
        entity1 (str): The entity1 value.
        entity2 (str | None): The entity2 value.
        dimension_type (str): The dimension type value.
        value (float): The value value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_sketch_dimension is not implemented by this adapter",
    )

add_spline async

add_spline(points: list[dict[str, float]]) -> AdapterResult[str]

Add a spline through the provided points.

Parameters:

Name	Type	Description	Default
points	list[dict[str, float]]	The points value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
    """Add a spline through the provided points.

    Args:
        points (list[dict[str, float]]): The points value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_spline is not implemented by this adapter",
    )

arrange_dimensions async

arrange_dimensions(view_name: str | None = None) -> AdapterResult[dict[str, Any]]

Move drawing dimensions so none overlaps, then verify.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def arrange_dimensions(
    self,
    view_name: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Move drawing dimensions so none overlaps, then verify.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="arrange_dimensions is not implemented by this adapter",
    )

auto_center_marks async

auto_center_marks(view_name: str, mark_holes: bool = True, mark_fillets: bool = False, mark_slots: bool = True) -> AdapterResult[dict[str, Any]]

Auto-insert centre marks on circular features in a drawing view.

Parameters:

Name	Type	Description	Default
view_name	str	Name of a view on the active drawing.	required
mark_holes	bool	Mark holes / bores.	True
mark_fillets	bool	Mark fillets.	False
mark_slots	bool	Mark slots.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The view and before/after centre-mark
AdapterResult[dict[str, Any]]	counts, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def auto_center_marks(
    self,
    view_name: str,
    mark_holes: bool = True,
    mark_fillets: bool = False,
    mark_slots: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Auto-insert centre marks on circular features in a drawing view.

    Args:
        view_name (str): Name of a view on the active drawing.
        mark_holes (bool): Mark holes / bores.
        mark_fillets (bool): Mark fillets.
        mark_slots (bool): Mark slots.

    Returns:
        AdapterResult[dict[str, Any]]: The view and before/after centre-mark
        counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="auto_center_marks is not implemented by this adapter",
    )

check_interference async

check_interference(params: Any = None) -> AdapterResult[dict[str, Any]]

Check the active assembly for interfering components.

Parameters:

Name	Type	Description	Default
params	Any	Optional settings; coincident, components.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Interference details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def check_interference(
    self, params: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Check the active assembly for interfering components.

    Args:
        params (Any): Optional settings; ``coincident``, ``components``.

    Returns:
        AdapterResult[dict[str, Any]]: Interference details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="check_interference is not implemented by this adapter",
    )

check_sketch_fully_defined async

check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Check whether a sketch is fully defined.

Parameters:

Name	Type	Description	Default
sketch_name	str | None	Optional sketch name to inspect. Defaults to None.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Definition status payload.

Source code in src/solidworks_mcp/adapters/base.py

async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Check whether a sketch is fully defined.

    Args:
        sketch_name (str | None): Optional sketch name to inspect. Defaults to None.

    Returns:
        AdapterResult[dict[str, Any]]: Definition status payload.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="check_sketch_fully_defined is not implemented by this adapter",
    )

close_model abstractmethod async

close_model(save: bool = False) -> AdapterResult[None]

Close the current model.

Parameters:

Name	Type	Description	Default
save	bool	The save value. Defaults to False.	False

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Close the current model.

    Args:
        save (bool): The save value. Defaults to False.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

connect abstractmethod async

connect() -> None

Connect to SolidWorks application.

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def connect(self) -> None:
    """Connect to SolidWorks application.

    Returns:
        None: None.
    """
    pass

create_assembly abstractmethod async

create_assembly(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new assembly document.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_assembly(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new assembly document.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_axis async

create_axis(reference: str) -> AdapterResult[dict[str, Any]]

Create a reference axis along a principal direction.

Parameters:

Name	Type	Description	Default
reference	str	"x", "y" or "z" (case-insensitive, leading ± stripped).	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The plane pair used and feature counts, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_axis(self, reference: str) -> AdapterResult[dict[str, Any]]:
    """Create a reference axis along a principal direction.

    Args:
        reference (str): "x", "y" or "z" (case-insensitive, leading +/- stripped).

    Returns:
        AdapterResult[dict[str, Any]]: The plane pair used and feature counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_axis is not implemented by this adapter",
    )

create_cut async

create_cut(sketch_name: str, depth: float) -> AdapterResult[str]

Create a cut feature from an existing sketch.

Parameters:

Name	Type	Description	Default
sketch_name	str	The sketch name value.	required
depth	float	The depth value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def create_cut(self, sketch_name: str, depth: float) -> AdapterResult[str]:
    """Create a cut feature from an existing sketch.

    Args:
        sketch_name (str): The sketch name value.
        depth (float): The depth value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_cut is not implemented by this adapter",
    )

create_cut_extrude async

create_cut_extrude(params: ExtrusionParameters) -> AdapterResult[Any]

Create a cut-extrude feature from the active sketch.

Cuts material from the current solid body using the active sketch profile. Equivalent to SolidWorks Insert > Cut > Extrude.

Parameters:

Name	Type	Description	Default
params	ExtrusionParameters	Depth and direction parameters.	required

Returns:

Name	Type	Description
AdapterResult	AdapterResult[Any]	Feature result or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_cut_extrude(
    self, params: ExtrusionParameters
) -> AdapterResult[Any]:
    """Create a cut-extrude feature from the active sketch.

    Cuts material from the current solid body using the active sketch profile.
    Equivalent to SolidWorks Insert > Cut > Extrude.

    Args:
        params (ExtrusionParameters): Depth and direction parameters.

    Returns:
        AdapterResult: Feature result or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_cut_extrude is not implemented by this adapter",
    )

create_drawing abstractmethod async

create_drawing(name: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new drawing document.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_drawing(
    self, name: str | None = None, template: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new drawing document.

    Args:
        name (str | None): The name value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_drawing_view async

create_drawing_view(payload: Any = None) -> AdapterResult[dict[str, Any]]

Place a view of a model on the active drawing sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path, orientation, position in millimetres and optional view scale.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The new view's details, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_drawing_view(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Place a view of a model on the active drawing sheet.

    Args:
        payload (Any): Tool payload carrying the model path, orientation,
            position in millimetres and optional view scale.

    Returns:
        AdapterResult[dict[str, Any]]: The new view's details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_drawing_view is not implemented by this adapter",
    )

create_extrusion abstractmethod async

create_extrusion(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create an extrusion feature.

Parameters:

Name	Type	Description	Default
params	ExtrusionParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_extrusion(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create an extrusion feature.

    Args:
        params (ExtrusionParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_loft abstractmethod async

create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Create a loft feature.

Parameters:

Name	Type	Description	Default
params	LoftParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a loft feature.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_part abstractmethod async

create_part(name: str | None = None, units: str | None = None, template: str | None = None) -> AdapterResult[SolidWorksModel]

Create a new part document.

Parameters:

Name	Type	Description	Default
name	str | None	The name value. Defaults to None.	None
units	str | None	The units value. Defaults to None.	None
template	str | None	Template file path. Defaults to None.	None

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_part(
    self,
    name: str | None = None,
    units: str | None = None,
    template: str | None = None,
) -> AdapterResult[SolidWorksModel]:
    """Create a new part document.

    Args:
        name (str | None): The name value. Defaults to None.
        units (str | None): The units value. Defaults to None.
        template (str | None): Template file path. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

create_reference_plane async

create_reference_plane(reference: str, offset: float = 0.0, angle: float = 0.0, flip: bool = False, axis: str | None = None, face_point: list[float] | None = None) -> AdapterResult[dict[str, Any]]

Create a reference plane offset from, angled to, or on a plane or face.

Parameters:

Name	Type	Description	Default
reference	str	Name of the reference plane.	required
offset	float	Offset distance in millimetres. Defaults to 0.0.	0.0
angle	float	Angle in degrees about axis. Defaults to 0.0.	0.0
flip	bool	Reverse the offset or angle direction. Defaults to False.	False
axis	str | None	Named axis to rotate about; needed with angle.	None
face_point	list[float] | None	[x, y, z] mm on a flat face to use as the reference instead of reference.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The new plane's name and parameters, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_reference_plane(
    self,
    reference: str,
    offset: float = 0.0,
    angle: float = 0.0,
    flip: bool = False,
    axis: str | None = None,
    face_point: list[float] | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Create a reference plane offset from, angled to, or on a plane or face.

    Args:
        reference (str): Name of the reference plane.
        offset (float): Offset distance in millimetres. Defaults to 0.0.
        angle (float): Angle in degrees about ``axis``. Defaults to 0.0.
        flip (bool): Reverse the offset or angle direction. Defaults to False.
        axis (str | None): Named axis to rotate about; needed with ``angle``.
        face_point (list[float] | None): ``[x, y, z]`` mm on a flat face to
            use as the reference instead of ``reference``.

    Returns:
        AdapterResult[dict[str, Any]]: The new plane's name and parameters, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_reference_plane is not implemented by this adapter",
    )

create_reference_point async

create_reference_point(mode: str, x: float, y: float, z: float, distance: float | None = None, percent: float | None = None) -> AdapterResult[dict[str, Any]]

Create a reference point on the active part.

Parameters:

Name	Type	Description	Default
mode	str	"along_curve" or "face_center".	required
x	float	X of a point on the target edge/face, in millimetres.	required
y	float	Y of a point on the target edge/face, in millimetres.	required
z	float	Z of a point on the target edge/face, in millimetres.	required
distance	float | None	For "along_curve", offset from the edge start in millimetres.	None
percent	float | None	For "along_curve", position as 0-100 of the edge length.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The mode and feature counts, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_reference_point(
    self,
    mode: str,
    x: float,
    y: float,
    z: float,
    distance: float | None = None,
    percent: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Create a reference point on the active part.

    Args:
        mode (str): "along_curve" or "face_center".
        x (float): X of a point on the target edge/face, in millimetres.
        y (float): Y of a point on the target edge/face, in millimetres.
        z (float): Z of a point on the target edge/face, in millimetres.
        distance (float | None): For "along_curve", offset from the edge
            start in millimetres.
        percent (float | None): For "along_curve", position as 0-100 of
            the edge length.

    Returns:
        AdapterResult[dict[str, Any]]: The mode and feature counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_reference_point is not implemented by this adapter",
    )

create_revolve abstractmethod async

create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Create a revolve feature.

Parameters:

Name	Type	Description	Default
params	RevolveParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a revolve feature.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_sketch abstractmethod async

create_sketch(plane: str) -> AdapterResult[str]

Create a new sketch on the specified plane.

Parameters:

Name	Type	Description	Default
plane	str	The plane value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_sketch(self, plane: str) -> AdapterResult[str]:
    """Create a new sketch on the specified plane.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass

create_standard_drawing async

create_standard_drawing(model_path: str, output_dir: str | None = None, title: str | None = None, subtitle: str | None = None, drawing_number: str | None = None, author: str = '', revision: str = 'A', company: str = '', drawn_date: str | None = None, notes: list[str] | None = None, include_isometric: bool = True, write_model_properties: bool = True, title_block_text_height_mm: float | None = None, include_bom: bool = False) -> AdapterResult[dict[str, Any]]

Create a complete standard A3 drawing.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def create_standard_drawing(
    self,
    model_path: str,
    output_dir: str | None = None,
    title: str | None = None,
    subtitle: str | None = None,
    drawing_number: str | None = None,
    author: str = "",
    revision: str = "A",
    company: str = "",
    drawn_date: str | None = None,
    notes: list[str] | None = None,
    include_isometric: bool = True,
    write_model_properties: bool = True,
    title_block_text_height_mm: float | None = None,
    include_bom: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Create a complete standard A3 drawing.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_standard_drawing is not implemented by this adapter",
    )

create_sweep abstractmethod async

create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Create a sweep feature.

Parameters:

Name	Type	Description	Default
params	SweepParameters	The params value.	required

Returns:

Type	Description
AdapterResult[SolidWorksFeature]	AdapterResult[SolidWorksFeature]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create a sweep feature.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    pass

create_technical_drawing async

create_technical_drawing(payload: Any = None) -> AdapterResult[dict[str, Any]]

Lay out the standard views of a model on the active sheet.

Parameters:

Name	Type	Description	Default
payload	Any	Tool payload carrying the model path and the projection angle.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The view names created, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def create_technical_drawing(
    self, payload: Any = None
) -> AdapterResult[dict[str, Any]]:
    """Lay out the standard views of a model on the active sheet.

    Args:
        payload (Any): Tool payload carrying the model path and the
            projection angle.

    Returns:
        AdapterResult[dict[str, Any]]: The view names created, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="create_technical_drawing is not implemented by this adapter",
    )

delete_feature async

delete_feature(name: str) -> AdapterResult[dict[str, Any]]

Delete a named feature or sketch from the active model.

Parameters:

Name	Type	Description	Default
name	str	Feature or sketch name.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: What was deleted, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def delete_feature(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Delete a named feature or sketch from the active model.

    Args:
        name (str): Feature or sketch name.

    Returns:
        AdapterResult[dict[str, Any]]: What was deleted, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="delete_feature is not implemented by this adapter",
    )

disconnect abstractmethod async

disconnect() -> None

Disconnect from SolidWorks application.

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def disconnect(self) -> None:
    """Disconnect from SolidWorks application.

    Returns:
        None: None.
    """
    pass

exit_sketch abstractmethod async

exit_sketch() -> AdapterResult[None]

Exit sketch editing mode.

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def exit_sketch(self) -> AdapterResult[None]:
    """Exit sketch editing mode.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

export_file abstractmethod async

export_file(file_path: str, format_type: str) -> AdapterResult[None]

Export the current model to a file.

Parameters:

Name	Type	Description	Default
file_path	str	Path to the target file.	required
format_type	str	The format type value.	required

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Export the current model to a file.

    Args:
        file_path (str): Path to the target file.
        format_type (str): The format type value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

export_flat_pattern async

export_flat_pattern(file_path: str) -> AdapterResult[dict[str, Any]]

Export the active sheet-metal part's flat pattern.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def export_flat_pattern(
    self,
    file_path: str,
) -> AdapterResult[dict[str, Any]]:
    """Export the active sheet-metal part's flat pattern.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="export_flat_pattern is not implemented by this adapter",
    )

export_image abstractmethod async

export_image(payload: dict) -> AdapterResult[dict]

Export a viewport screenshot (PNG/JPG) of the current model.

Payload keys: file_path (str): Absolute output path. width (int): Image width in pixels. height (int): Image height in pixels. view_orientation (str): One of "isometric", "front", "top", "right", "back", "bottom", "current".

Parameters:

Name	Type	Description	Default
payload	dict	The payload value.	required

Returns:

Type	Description
AdapterResult[dict]	AdapterResult[dict]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Export a viewport screenshot (PNG/JPG) of the current model.

    Payload keys: file_path (str): Absolute output path. width (int): Image width in pixels.
    height (int): Image height in pixels. view_orientation (str): One of "isometric",
    "front", "top", "right", "back", "bottom", "current".

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    pass

get_application_info async

get_application_info() -> AdapterResult[dict[str, Any]]

Describe the connected SolidWorks without changing anything.

Only file names leave the adapter, never full paths, so the result can be pasted into a public report. A value that cannot be read is None, never guessed.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: revision (e.g. "34.4.0"),
AdapterResult[dict[str, Any]]	language (e.g. "english") and templates: for each of
AdapterResult[dict[str, Any]]	part, assembly and drawing, the default template's
AdapterResult[dict[str, Any]]	file_name and whether the file exists.

Source code in src/solidworks_mcp/adapters/base.py

async def get_application_info(self) -> AdapterResult[dict[str, Any]]:
    """Describe the connected SolidWorks without changing anything.

    Only file names leave the adapter, never full paths, so the result
    can be pasted into a public report. A value that cannot be read is
    ``None``, never guessed.

    Returns:
        AdapterResult[dict[str, Any]]: ``revision`` (e.g. ``"34.4.0"``),
        ``language`` (e.g. ``"english"``) and ``templates``: for each of
        ``part``, ``assembly`` and ``drawing``, the default template's
        ``file_name`` and whether the file ``exists``.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="get_application_info is not implemented by this adapter",
    )

get_custom_properties async

get_custom_properties(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Read the custom properties of the active document.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def get_custom_properties(
    self,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Read the custom properties of the active document.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="get_custom_properties is not implemented by this adapter",
    )

get_dimension abstractmethod async

get_dimension(name: str) -> AdapterResult[dict[str, Any]]

Get the value of a dimension.

Parameters:

Name	Type	Description	Default
name	str	The name value.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: value and units (mm, deg or None).

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_dimension(self, name: str) -> AdapterResult[dict[str, Any]]:
    """Get the value of a dimension.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[dict[str, Any]]: ``value`` and ``units`` (mm, deg or None).
    """
    pass

get_mass_properties abstractmethod async

get_mass_properties() -> AdapterResult[MassProperties]

Get mass properties of the current model.

Returns:

Type	Description
AdapterResult[MassProperties]	AdapterResult[MassProperties]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Get mass properties of the current model.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    pass

get_material async

get_material(configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Read the material assigned to the active part.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def get_material(
    self,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Read the material assigned to the active part.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="get_material is not implemented by this adapter",
    )

get_metrics

get_metrics() -> dict[str, Any]

Get adapter metrics.

Returns:

Type	Description
dict[str, Any]	dict[str, Any]: A dictionary containing the resulting values.

Source code in src/solidworks_mcp/adapters/base.py

def get_metrics(self) -> dict[str, Any]:
    """Get adapter metrics.

    Returns:
        dict[str, Any]: A dictionary containing the resulting values.
    """
    return self._metrics.copy()

get_model_geometry_summary async

get_model_geometry_summary() -> AdapterResult[dict[str, Any]]

Summarise the active part or assembly without changing it.

Must not rebuild the model, modify it, or clear the selection, so callers can read it around a feature call. Values the adapter cannot determine are None, never guessed.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: document_type ("part" or
AdapterResult[dict[str, Any]]	"assembly"), volume_mm3, bounding_box_mm (min,
AdapterResult[dict[str, Any]]	max and size as [x, y, z]), bounding_box_method,
AdapterResult[dict[str, Any]]	solid_body_count, and for assemblies component_count and
AdapterResult[dict[str, Any]]	mate_count. Error when there is no active part or assembly.

Source code in src/solidworks_mcp/adapters/base.py

async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
    """Summarise the active part or assembly without changing it.

    Must not rebuild the model, modify it, or clear the selection, so
    callers can read it around a feature call. Values the adapter cannot
    determine are ``None``, never guessed.

    Returns:
        AdapterResult[dict[str, Any]]: ``document_type`` (``"part"`` or
        ``"assembly"``), ``volume_mm3``, ``bounding_box_mm`` (``min``,
        ``max`` and ``size`` as ``[x, y, z]``), ``bounding_box_method``,
        ``solid_body_count``, and for assemblies ``component_count`` and
        ``mate_count``. Error when there is no active part or assembly.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="get_model_geometry_summary is not implemented by this adapter",
    )

get_model_info abstractmethod async

get_model_info() -> AdapterResult[dict[str, Any]]

Get metadata for the active model.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
    """Get metadata for the active model.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    pass

get_selected_entities async

get_selected_entities() -> AdapterResult[list[dict[str, Any]]]

Report the faces/edges/vertices currently selected in the live UI.

Lets an agent see exactly what the user has clicked on in SolidWorks (e.g. "chamfer THIS face") instead of inferring it from a screenshot.

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: One descriptor per selected
AdapterResult[list[dict[str, Any]]]	entity. See the PyWin32 adapter's implementation for the field
AdapterResult[list[dict[str, Any]]]	set (varies by entity type).

Source code in src/solidworks_mcp/adapters/base.py

async def get_selected_entities(self) -> AdapterResult[list[dict[str, Any]]]:
    """Report the faces/edges/vertices currently selected in the live UI.

    Lets an agent see exactly what the user has clicked on in SolidWorks
    (e.g. "chamfer THIS face") instead of inferring it from a screenshot.

    Returns:
        AdapterResult[list[dict[str, Any]]]: One descriptor per selected
        entity. See the PyWin32 adapter's implementation for the field
        set (varies by entity type).
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="get_selected_entities is not implemented by this adapter",
    )

health_check abstractmethod async

health_check() -> AdapterHealth

Get adapter health status.

Returns:

Name	Type	Description
AdapterHealth	AdapterHealth	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def health_check(self) -> AdapterHealth:
    """Get adapter health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    pass

insert_bom_table async

insert_bom_table(view_name: str, template_path: str | None = None, bom_type: str = 'top_level_only', x_mm: float | None = None, y_mm: float | None = None) -> AdapterResult[dict[str, Any]]

Insert a BOM table anchored to an assembly drawing view.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def insert_bom_table(
    self,
    view_name: str,
    template_path: str | None = None,
    bom_type: str = "top_level_only",
    x_mm: float | None = None,
    y_mm: float | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Insert a BOM table anchored to an assembly drawing view.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="insert_bom_table is not implemented by this adapter",
    )

insert_component async

insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Insert a part or sub-assembly into the active assembly.

Parameters:

Name	Type	Description	Default
file_path	str	Absolute path to the .sldprt or .sldasm.	required
x	float	X position in millimetres. Defaults to 0.0.	0.0
y	float	Y position in millimetres. Defaults to 0.0.	0.0
z	float	Z position in millimetres. Defaults to 0.0.	0.0

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Component name and counts, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Insert a part or sub-assembly into the active assembly.

    Args:
        file_path (str): Absolute path to the ``.sldprt`` or ``.sldasm``.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: Component name and counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="insert_component is not implemented by this adapter",
    )

insert_model_dimensions async

insert_model_dimensions(view_name: str | None = None, include_hole_wizard: bool = True) -> AdapterResult[dict[str, Any]]

Bring model dimensions into drawing views.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def insert_model_dimensions(
    self,
    view_name: str | None = None,
    include_hole_wizard: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Bring model dimensions into drawing views.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="insert_model_dimensions is not implemented by this adapter",
    )

is_connected abstractmethod

is_connected() -> bool

Check if connected to SolidWorks.

Returns:

Name	Type	Description
bool	bool	True if connected, otherwise False.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
def is_connected(self) -> bool:
    """Check if connected to SolidWorks.

    Returns:
        bool: True if connected, otherwise False.
    """
    pass

list_available_materials async

list_available_materials(search: str | None = None) -> AdapterResult[list[dict[str, str]]]

List materials from the configured material libraries.

Returns:

Type	Description
AdapterResult[list[dict[str, str]]]	AdapterResult[list[dict[str, str]]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def list_available_materials(
    self,
    search: str | None = None,
) -> AdapterResult[list[dict[str, str]]]:
    """List materials from the configured material libraries.

    Returns:
        AdapterResult[list[dict[str, str]]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_available_materials is not implemented by this adapter",
    )

list_components async

list_components() -> AdapterResult[list[str]]

List the top-level components of the active assembly.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: Component instance names, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def list_components(self) -> AdapterResult[list[str]]:
    """List the top-level components of the active assembly.

    Returns:
        AdapterResult[list[str]]: Component instance names, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_components is not implemented by this adapter",
    )

list_configurations abstractmethod async

list_configurations() -> AdapterResult[list[str]]

List configuration names for the active model.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def list_configurations(self) -> AdapterResult[list[str]]:
    """List configuration names for the active model.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    pass

list_drawing_views async

list_drawing_views() -> AdapterResult[list[str]]

List the views on the active drawing.

Returns:

Type	Description
AdapterResult[list[str]]	AdapterResult[list[str]]: View names, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def list_drawing_views(self) -> AdapterResult[list[str]]:
    """List the views on the active drawing.

    Returns:
        AdapterResult[list[str]]: View names, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_drawing_views is not implemented by this adapter",
    )

list_features abstractmethod async

list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

List model features from the feature tree.

For a Part document, returns that document's own feature list, unchanged from prior behavior. For an Assembly document, returns a single flat list containing the assembly's own top-level features plus every resolved component's features, recursing into sub-assemblies up to max_assembly_depth. Every descriptor gains component, component_path, and component_parent keys: None for a document's own features (Part features, or an Assembly's top-level features), or the owning component's name/path for a component-derived feature. component_parent is the immediate parent component name when the component is nested inside a sub-assembly, otherwise None. A component that cannot be resolved (suppressed, lightweight-and-unloaded, missing file) is represented by one descriptor with type: "UnresolvedComponent" instead of being silently dropped.

Parameters:

Name	Type	Description	Default
include_suppressed	bool	The include suppressed value. Defaults to False. Applied independently to the assembly's own features and to each component's features.	False
max_assembly_depth	int	How many levels of sub-assembly to recurse into. Defaults to 2. Ignored for Part documents. A component beyond the configured depth still appears in the result as a single descriptor (name + path), not expanded.	2

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """List model features from the feature tree.

    For a Part document, returns that document's own feature list,
    unchanged from prior behavior. For an Assembly document, returns a
    single flat list containing the assembly's own top-level features
    plus every resolved component's features, recursing into
    sub-assemblies up to ``max_assembly_depth``. Every descriptor gains
    ``component``, ``component_path``, and ``component_parent`` keys:
    ``None`` for a document's own features (Part features, or an Assembly's
    top-level features), or the owning component's name/path for a
    component-derived feature. ``component_parent`` is the immediate parent
    component name when the component is nested inside a sub-assembly,
    otherwise ``None``. A component that cannot be resolved (suppressed,
    lightweight-and-unloaded, missing file) is represented by one descriptor
    with ``type: "UnresolvedComponent"`` instead of being silently dropped.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
            Applied independently to the assembly's own features and to
            each component's features.
        max_assembly_depth (int): How many levels of sub-assembly to
            recurse into. Defaults to 2. Ignored for Part documents. A
            component beyond the configured depth still appears in the
            result as a single descriptor (name + path), not expanded.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    pass

list_model_dimensions async

list_model_dimensions(feature_name: str | None = None) -> AdapterResult[list[dict[str, Any]]]

List every dimension in the active part or assembly.

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def list_model_dimensions(
    self,
    feature_name: str | None = None,
) -> AdapterResult[list[dict[str, Any]]]:
    """List every dimension in the active part or assembly.

    Returns:
        AdapterResult[list[dict[str, Any]]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_model_dimensions is not implemented by this adapter",
    )

list_open_documents async

list_open_documents() -> AdapterResult[list[dict[str, Any]]]

Enumerate every document currently open in SolidWorks.

Returns:

Type	Description
AdapterResult[list[dict[str, Any]]]	AdapterResult[list[dict[str, Any]]]: One entry per open document
AdapterResult[list[dict[str, Any]]]	(title, path, type, is_active), or error.

Source code in src/solidworks_mcp/adapters/base.py

async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
    """Enumerate every document currently open in SolidWorks.

    Returns:
        AdapterResult[list[dict[str, Any]]]: One entry per open document
        (``title``, ``path``, ``type``, ``is_active``), or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_open_documents is not implemented by this adapter",
    )

measure_entities async

measure_entities(entities: list[str]) -> AdapterResult[dict[str, Any]]

Measure one or two selected entities.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def measure_entities(
    self,
    entities: list[str],
) -> AdapterResult[dict[str, Any]]:
    """Measure one or two selected entities.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="measure_entities is not implemented by this adapter",
    )

mirror_feature async

mirror_feature(features: list[str], mirror_plane: str, merge: bool = True, mirror_bodies: bool = True) -> AdapterResult[dict[str, Any]]

Mirror solid bodies or features about a plane.

Parameters:

Name	Type	Description	Default
features	list[str]	Body or feature names to mirror.	required
mirror_plane	str	Plane name to mirror about.	required
merge	bool	Merge the mirrored result with the original. Defaults to True.	True
mirror_bodies	bool	Mirror whole bodies rather than features. Defaults to True.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The mirror feature's name, inputs and volume
AdapterResult[dict[str, Any]]	before/after, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def mirror_feature(
    self,
    features: list[str],
    mirror_plane: str,
    merge: bool = True,
    mirror_bodies: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Mirror solid bodies or features about a plane.

    Args:
        features (list[str]): Body or feature names to mirror.
        mirror_plane (str): Plane name to mirror about.
        merge (bool): Merge the mirrored result with the original. Defaults to True.
        mirror_bodies (bool): Mirror whole bodies rather than features. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: The mirror feature's name, inputs and volume
        before/after, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="mirror_feature is not implemented by this adapter",
    )

open_model abstractmethod async

open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Open a SolidWorks model (part, assembly, or drawing).

Parameters:

Name	Type	Description	Default
file_path	str	Path to the target file.	required

Returns:

Type	Description
AdapterResult[SolidWorksModel]	AdapterResult[SolidWorksModel]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Open a SolidWorks model (part, assembly, or drawing).

    Args:
        file_path (str): Path to the target file.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass

pattern_circular async

pattern_circular(features: list[str], axis: str, count: int, angle: float = 360.0, equal_spacing: bool = True) -> AdapterResult[dict[str, Any]]

Pattern features around an axis.

Parameters:

Name	Type	Description	Default
features	list[str]	Names of the features to pattern.	required
axis	str	Name of the axis to rotate about.	required
count	int	Total number of instances including the original.	required
angle	float	Total angle in degrees to spread them over. Defaults to 360.0.	360.0
equal_spacing	bool	Space instances evenly across angle. Defaults to True.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: What was patterned and the volume
AdapterResult[dict[str, Any]]	before/after, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def pattern_circular(
    self,
    features: list[str],
    axis: str,
    count: int,
    angle: float = 360.0,
    equal_spacing: bool = True,
) -> AdapterResult[dict[str, Any]]:
    """Pattern features around an axis.

    Args:
        features (list[str]): Names of the features to pattern.
        axis (str): Name of the axis to rotate about.
        count (int): Total number of instances including the original.
        angle (float): Total angle in degrees to spread them over. Defaults to 360.0.
        equal_spacing (bool): Space instances evenly across ``angle``. Defaults to True.

    Returns:
        AdapterResult[dict[str, Any]]: What was patterned and the volume
        before/after, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="pattern_circular is not implemented by this adapter",
    )

rebuild_model async

rebuild_model(top_level_only: bool = False) -> AdapterResult[dict[str, Any]]

Force a rebuild and report per-feature rebuild errors.

Parameters:

Name	Type	Description	Default
top_level_only	bool	Rebuild only the top level of an assembly. Defaults to False (full rebuild).	False

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: rebuilt, top_level_only,
AdapterResult[dict[str, Any]]	errors (one entry per failing feature with feature,
AdapterResult[dict[str, Any]]	type, code, code_name, severity, description,
AdapterResult[dict[str, Any]]	parents, hint), error_count and warning_count.
AdapterResult[dict[str, Any]]	ERROR (still carrying data) when any error-severity entry
AdapterResult[dict[str, Any]]	remains.

Source code in src/solidworks_mcp/adapters/base.py

async def rebuild_model(
    self, top_level_only: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Force a rebuild and report per-feature rebuild errors.

    Args:
        top_level_only (bool): Rebuild only the top level of an assembly.
            Defaults to False (full rebuild).

    Returns:
        AdapterResult[dict[str, Any]]: ``rebuilt``, ``top_level_only``,
        ``errors`` (one entry per failing feature with ``feature``,
        ``type``, ``code``, ``code_name``, ``severity``, ``description``,
        ``parents``, ``hint``), ``error_count`` and ``warning_count``.
        ERROR (still carrying ``data``) when any error-severity entry
        remains.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="rebuild_model is not implemented by this adapter",
    )

rename_feature async

rename_feature(old_name: str, new_name: str) -> AdapterResult[dict[str, Any]]

Rename an existing feature on the feature tree.

Parameters:

Name	Type	Description	Default
old_name	str	Current feature name.	required
new_name	str	New feature name.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The old and new names, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def rename_feature(
    self, old_name: str, new_name: str
) -> AdapterResult[dict[str, Any]]:
    """Rename an existing feature on the feature tree.

    Args:
        old_name (str): Current feature name.
        new_name (str): New feature name.

    Returns:
        AdapterResult[dict[str, Any]]: The old and new names, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="rename_feature is not implemented by this adapter",
    )

reset_circuit_breakers async

reset_circuit_breakers(operation: str | None = None) -> AdapterResult[dict[str, list[str]]]

Re-open operations a circuit breaker paused.

An adapter without a circuit breaker has nothing paused; the breaker and the connection pool override this.

Parameters:

Name	Type	Description	Default
operation	str | None	The operation to reset; None resets every one.	None

Returns:

Type	Description
AdapterResult[dict[str, list[str]]]	AdapterResult[dict[str, list[str]]]: reset, the operations that were paused.

Source code in src/solidworks_mcp/adapters/base.py

async def reset_circuit_breakers(
    self, operation: str | None = None
) -> AdapterResult[dict[str, list[str]]]:
    """Re-open operations a circuit breaker paused.

    An adapter without a circuit breaker has nothing paused; the breaker
    and the connection pool override this.

    Args:
        operation: The operation to reset; ``None`` resets every one.

    Returns:
        AdapterResult[dict[str, list[str]]]: ``reset``, the operations that were paused.
    """
    return AdapterResult(status=AdapterResultStatus.SUCCESS, data={"reset": []})

save_body_as_part async

save_body_as_part(body_name: str, file_path: str) -> AdapterResult[dict[str, Any]]

Extract one solid body from the active multibody part to a new file.

Parameters:

Name	Type	Description	Default
body_name	str	Name of a solid body in the active part.	required
file_path	str	Absolute path for the new .sldprt.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The body, the written path, and the
AdapterResult[dict[str, Any]]	solid-body names found, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def save_body_as_part(
    self, body_name: str, file_path: str
) -> AdapterResult[dict[str, Any]]:
    """Extract one solid body from the active multibody part to a new file.

    Args:
        body_name (str): Name of a solid body in the active part.
        file_path (str): Absolute path for the new ``.sldprt``.

    Returns:
        AdapterResult[dict[str, Any]]: The body, the written path, and the
        solid-body names found, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="save_body_as_part is not implemented by this adapter",
    )

save_file async

save_file(file_path: str | None = None) -> AdapterResult[Any]

Save the active model to the existing path or the provided path.

Parameters:

Name	Type	Description	Default
file_path	str | None	Path to the target file. Defaults to None.	None

Returns:

Type	Description
AdapterResult[Any]	AdapterResult[Any]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def save_file(self, file_path: str | None = None) -> AdapterResult[Any]:
    """Save the active model to the existing path or the provided path.

    Args:
        file_path (str | None): Path to the target file. Defaults to None.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="save_file is not implemented by this adapter",
    )

select_face_edges async

select_face_edges(point: list[float] | None = None, side: str | None = None, plane: str | None = None, edge_type: str = 'all', append: bool = False) -> AdapterResult[dict[str, Any]]

Multi-select every edge bounding one face of the active part.

Exactly one of point/side/plane identifies the face.

Parameters:

Name	Type	Description	Default
point	list[float] | None	[x, y, z] in mm on the face.	None
side	str | None	+X..-Z or top/bottom/front/back/ right/left; the furthest planar face facing that way.	None
plane	str | None	Reference plane name; the body face(s) lying on it.	None
edge_type	str	all, linear or circular.	'all'
append	bool	Add to the current selection. Defaults to False.	False

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: face (or faces), edges
AdapterResult[dict[str, Any]]	(one descriptor per selected edge) and selection_count.

Source code in src/solidworks_mcp/adapters/base.py

async def select_face_edges(
    self,
    point: list[float] | None = None,
    side: str | None = None,
    plane: str | None = None,
    edge_type: str = "all",
    append: bool = False,
) -> AdapterResult[dict[str, Any]]:
    """Multi-select every edge bounding one face of the active part.

    Exactly one of ``point``/``side``/``plane`` identifies the face.

    Args:
        point (list[float] | None): ``[x, y, z]`` in mm on the face.
        side (str | None): ``+X``..``-Z`` or ``top/bottom/front/back/
            right/left``; the furthest planar face facing that way.
        plane (str | None): Reference plane name; the body face(s) lying
            on it.
        edge_type (str): ``all``, ``linear`` or ``circular``.
        append (bool): Add to the current selection. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: ``face`` (or ``faces``), ``edges``
        (one descriptor per selected edge) and ``selection_count``.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="select_face_edges is not implemented by this adapter",
    )

select_feature async

select_feature(feature_name: str, append: bool = False) -> AdapterResult[dict[str, Any]]

Select a named feature, sketch, plane or component.

Parameters:

Name	Type	Description	Default
feature_name	str	The feature name, optionally @document qualified.	required
append	bool	Add to the current selection instead of replacing it. Defaults to False.	False

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: On success selected (True),
AdapterResult[dict[str, Any]]	feature_name, selected_name, entity_type and
AdapterResult[dict[str, Any]]	selection_count. ERROR when nothing could be selected - never
AdapterResult[dict[str, Any]]	SUCCESS with selected: False.

Source code in src/solidworks_mcp/adapters/base.py

async def select_feature(
    self, feature_name: str, append: bool = False
) -> AdapterResult[dict[str, Any]]:
    """Select a named feature, sketch, plane or component.

    Args:
        feature_name (str): The feature name, optionally ``@document``
            qualified.
        append (bool): Add to the current selection instead of replacing
            it. Defaults to False.

    Returns:
        AdapterResult[dict[str, Any]]: On success ``selected`` (True),
        ``feature_name``, ``selected_name``, ``entity_type`` and
        ``selection_count``. ERROR when nothing could be selected - never
        SUCCESS with ``selected: False``.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="select_feature is not implemented by this adapter",
    )

set_component_state async

set_component_state(component: str, fixed: bool | None = None, flexible: bool | None = None) -> AdapterResult[dict[str, Any]]

Fix or float a component, and make a sub-assembly rigid or flexible.

Parameters:

Name	Type	Description	Default
component	str	Instance name, as list_components reports it.	required
fixed	bool | None	True fixes it, False floats it.	None
flexible	bool | None	True flexible, False rigid.	None

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The state before and after, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def set_component_state(
    self,
    component: str,
    fixed: bool | None = None,
    flexible: bool | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Fix or float a component, and make a sub-assembly rigid or flexible.

    Args:
        component (str): Instance name, as ``list_components`` reports it.
        fixed (bool | None): True fixes it, False floats it.
        flexible (bool | None): True flexible, False rigid.

    Returns:
        AdapterResult[dict[str, Any]]: The state before and after, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="set_component_state is not implemented by this adapter",
    )

set_custom_property async

set_custom_property(name: str, value: str, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Create or overwrite one custom property.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def set_custom_property(
    self,
    name: str,
    value: str,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Create or overwrite one custom property.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="set_custom_property is not implemented by this adapter",
    )

set_dimension abstractmethod async

set_dimension(name: str, value: float) -> AdapterResult[None]

Set the value of a dimension.

Parameters:

Name	Type	Description	Default
name	str	The name value.	required
value	float	The value value.	required

Returns:

Type	Description
AdapterResult[None]	AdapterResult[None]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

@abstractmethod
async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Set the value of a dimension.

    Args:
        name (str): The name value.
        value (float): The value value.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    pass

set_material async

set_material(material_name: str, database: str | None = None, configuration: str | None = None) -> AdapterResult[dict[str, Any]]

Assign a material to the active part.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def set_material(
    self,
    material_name: str,
    database: str | None = None,
    configuration: str | None = None,
) -> AdapterResult[dict[str, Any]]:
    """Assign a material to the active part.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="set_material is not implemented by this adapter",
    )

set_sheet_scale async

set_sheet_scale(numerator: float, denominator: float) -> AdapterResult[dict[str, Any]]

Set the active drawing sheet's scale.

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Error unless the adapter implements it.

Source code in src/solidworks_mcp/adapters/base.py

async def set_sheet_scale(
    self,
    numerator: float,
    denominator: float,
) -> AdapterResult[dict[str, Any]]:
    """Set the active drawing sheet's scale.

    Returns:
        AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="set_sheet_scale is not implemented by this adapter",
    )

set_units async

set_units(unit_system: str) -> AdapterResult[dict[str, Any]]

Set the active document's linear unit system.

Parameters:

Name	Type	Description	Default
unit_system	str	One of mm, cm, m, in, ft.	required

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: What was applied, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
    """Set the active document's linear unit system.

    Args:
        unit_system (str): One of ``mm``, ``cm``, ``m``, ``in``, ``ft``.

    Returns:
        AdapterResult[dict[str, Any]]: What was applied, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="set_units is not implemented by this adapter",
    )

sketch_circular_pattern async

sketch_circular_pattern(entities: list[str], angle: float, count: int) -> AdapterResult[str]

Create a circular pattern of sketch entities around the sketch origin.

The rotation axis is always the sketch origin — SW's CreateCircularSketchStepAndRepeat has no pattern-centre parameter and derives the axis from the seed's geometry. Place the seed entity at the desired radius from the origin.

Parameters:

Name	Type	Description	Default
entities	list[str]	The entities value.	required
angle	float	The angle value.	required
count	int	The count value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_circular_pattern(
    self,
    entities: list[str],
    angle: float,
    count: int,
) -> AdapterResult[str]:
    """Create a circular pattern of sketch entities around the sketch origin.

    The rotation axis is always the sketch origin — SW's
    ``CreateCircularSketchStepAndRepeat`` has no pattern-centre
    parameter and derives the axis from the seed's geometry. Place
    the seed entity at the desired radius from the origin.

    Args:
        entities (list[str]): The entities value.
        angle (float): The angle value.
        count (int): The count value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_circular_pattern is not implemented by this adapter",
    )

sketch_linear_pattern async

sketch_linear_pattern(entities: list[str], direction_x: float, direction_y: float, spacing: float, count: int) -> AdapterResult[str]

Create a linear pattern of sketch entities.

Parameters:

Name	Type	Description	Default
entities	list[str]	The entities value.	required
direction_x	float	The direction x value.	required
direction_y	float	The direction y value.	required
spacing	float	The spacing value.	required
count	int	The count value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_linear_pattern(
    self,
    entities: list[str],
    direction_x: float,
    direction_y: float,
    spacing: float,
    count: int,
) -> AdapterResult[str]:
    """Create a linear pattern of sketch entities.

    Args:
        entities (list[str]): The entities value.
        direction_x (float): The direction x value.
        direction_y (float): The direction y value.
        spacing (float): The spacing value.
        count (int): The count value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_linear_pattern is not implemented by this adapter",
    )

sketch_mirror async

sketch_mirror(entities: list[str], mirror_line: str) -> AdapterResult[str]

Mirror sketch entities about a mirror line.

Parameters:

Name	Type	Description	Default
entities	list[str]	The entities value.	required
mirror_line	str	The mirror line value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_mirror(
    self, entities: list[str], mirror_line: str
) -> AdapterResult[str]:
    """Mirror sketch entities about a mirror line.

    Args:
        entities (list[str]): The entities value.
        mirror_line (str): The mirror line value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_mirror is not implemented by this adapter",
    )

sketch_offset async

sketch_offset(entities: list[str], offset_distance: float, reverse_direction: bool) -> AdapterResult[str]

Offset sketch entities.

Parameters:

Name	Type	Description	Default
entities	list[str]	The entities value.	required
offset_distance	float	The offset distance value.	required
reverse_direction	bool	The reverse direction value.	required

Returns:

Type	Description
AdapterResult[str]	AdapterResult[str]: The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

async def sketch_offset(
    self,
    entities: list[str],
    offset_distance: float,
    reverse_direction: bool,
) -> AdapterResult[str]:
    """Offset sketch entities.

    Args:
        entities (list[str]): The entities value.
        offset_distance (float): The offset distance value.
        reverse_direction (bool): The reverse direction value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="sketch_offset is not implemented by this adapter",
    )

suppress_feature async

suppress_feature(name: str, suppress: bool = True) -> AdapterResult[dict[str, Any]]

Suppress or unsuppress a named feature.

Parameters:

Name	Type	Description	Default
name	str	Feature name.	required
suppress	bool	True to suppress, False to unsuppress.	True

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: The resulting state, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def suppress_feature(
    self, name: str, suppress: bool = True
) -> AdapterResult[dict[str, Any]]:
    """Suppress or unsuppress a named feature.

    Args:
        name (str): Feature name.
        suppress (bool): True to suppress, False to unsuppress.

    Returns:
        AdapterResult[dict[str, Any]]: The resulting state, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="suppress_feature is not implemented by this adapter",
    )

undo async

undo(count: int = 1) -> AdapterResult[dict[str, Any]]

Undo the last operations in the active model.

Parameters:

Name	Type	Description	Default
count	int	Number of steps to undo.	1

Returns:

Type	Description
AdapterResult[dict[str, Any]]	AdapterResult[dict[str, Any]]: Whether the tree changed, or error.

Source code in src/solidworks_mcp/adapters/base.py

async def undo(self, count: int = 1) -> AdapterResult[dict[str, Any]]:
    """Undo the last operations in the active model.

    Args:
        count (int): Number of steps to undo.

    Returns:
        AdapterResult[dict[str, Any]]: Whether the tree changed, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="undo is not implemented by this adapter",
    )

update_metrics

update_metrics(operation_time: float, success: bool) -> None

Update adapter metrics.

Parameters:

Name	Type	Description	Default
operation_time	float	The operation time value.	required
success	bool	The success value.	required

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/base.py

def update_metrics(self, operation_time: float, success: bool) -> None:
    """Update adapter metrics.

    Args:
        operation_time (float): The operation time value.
        success (bool): The success value.

    Returns:
        None: None.
    """
    self._metrics["operations_count"] += 1
    if not success:
        self._metrics["errors_count"] += 1

    # Update average response time
    current_avg = self._metrics["average_response_time"]
    count = self._metrics["operations_count"]
    self._metrics["average_response_time"] = (
        current_avg * (count - 1) + operation_time
    ) / count

SolidWorksFeature

Bases: BaseModel

SolidWorks feature information.

Attributes:

Name	Type	Description
id	str | None	The id value.
name	str	The name value.
parameters	dict[str, Any] | None	The parameters value.
parent	str | None	The parent value.
properties	dict[str, Any] | None	The properties value.
type	str	The type value.

Methods:

__getitem__

__getitem__(key: str) -> Any

Build internal getitem.

Parameters:

Name	Type	Description	Default
key	str	The key value.	required

Returns:

Name	Type	Description
Any	Any	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

def __getitem__(self, key: str) -> Any:
    """Build internal getitem.

    Args:
        key (str): The key value.

    Returns:
        Any: The result produced by the operation.
    """
    if self.parameters and key in self.parameters:
        return self.parameters.get(key)
    return self.model_dump().get(key)

SolidWorksModel

Bases: BaseModel

SolidWorks model information.

Attributes:

Name	Type	Description
configuration	str | None	The configuration value.
is_active	bool	The is active value.
name	str	The name value.
path	str	The path value.
properties	dict[str, Any] | None	The properties value.
type	str	The type value.

Methods:

__getitem__

__getitem__(key: str) -> Any

Build internal getitem.

Parameters:

Name	Type	Description	Default
key	str	The key value.	required

Returns:

Name	Type	Description
Any	Any	The result produced by the operation.

Source code in src/solidworks_mcp/adapters/base.py

def __getitem__(self, key: str) -> Any:
    """Build internal getitem.

    Args:
        key (str): The key value.

    Returns:
        Any: The result produced by the operation.
    """
    if key == "title":
        return self.name
    if key == "units":
        return (self.properties or {}).get("units")
    return self.model_dump().get(key)

SolidWorksOperationError

Bases: SolidWorksMCPError

Exception raised when SolidWorks operation fails.

SweepParameters

Bases: BaseModel

Parameters for sweep operations.

Attributes:

Name	Type	Description
merge_result	bool	The merge result value.
path	str	The path value.
twist_along_path	bool	The twist along path value.
twist_angle	float	The twist angle value.

_BoolCallable

_BoolCallable(getter: Callable[[], bool])

Compatibility shim that behaves as both bool and callable.

Parameters:

Name	Type	Description	Default
getter	Callable[[], bool]	The getter value.	required

Attributes:

Name	Type	Description
_getter	Any	The getter value.

Initialize the bool callable.

Parameters:

Name	Type	Description	Default
getter	Callable[[], bool]	The getter value.	required

Returns:

Name	Type	Description
None	None	None.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __init__(self, getter: Callable[[], bool]) -> None:
    """Initialize the bool callable.

    Args:
        getter (Callable[[], bool]): The getter value.

    Returns:
        None: None.
    """
    self._getter = getter

Methods:

__bool__

__bool__() -> bool

Build internal bool.

Returns:

Name	Type	Description
bool	bool	True if bool, otherwise False.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __bool__(self) -> bool:
    """Build internal bool.

    Returns:
        bool: True if bool, otherwise False.
    """
    return bool(self._getter())

__call__

__call__() -> bool

Build internal call.

Returns:

Name	Type	Description
bool	bool	True if call, otherwise False.

Source code in src/solidworks_mcp/adapters/mock_adapter.py

def __call__(self) -> bool:
    """Build internal call.

    Returns:
        bool: True if call, otherwise False.
    """
    return bool(self._getter())

Functions:

_normalise_mock_unit_system

_normalise_mock_unit_system(unit_system: str) -> str | None

Map a user-supplied unit token onto a canonical key of _SW_UNIT_SYSTEMS.

Parameters:

Name	Type	Description	Default
unit_system	str	e.g. "mm", "inch", "Millimeters".	required

Returns:

Type	Description
str | None	str | None: "mm" | "cm" | "m" | "in" | "ft", or None when
str | None	the token is not recognised.

Source code in src/solidworks_mcp/adapters/solidworks/io.py

def _normalise_unit_system(unit_system: str) -> str | None:
    """Map a user-supplied unit token onto a canonical key of ``_SW_UNIT_SYSTEMS``.

    Args:
        unit_system: e.g. ``"mm"``, ``"inch"``, ``"Millimeters"``.

    Returns:
        str | None: ``"mm" | "cm" | "m" | "in" | "ft"``, or ``None`` when
        the token is not recognised.
    """
    return _SW_UNIT_ALIASES.get((unit_system or "").strip().lower())

gtol_problem

gtol_problem(characteristic: str, tolerance: float, material_condition: str, datums: list[str] | None) -> str | None

Why a feature control frame's inputs are invalid, or None when valid.

Shared by the real and mock adapters so both refuse the same inputs.

Parameters:

Name	Type	Description	Default
characteristic	str	The GD&T characteristic name.	required
tolerance	float	The tolerance value.	required
material_condition	str	none, mmc or lmc.	required
datums	list[str] | None	Datum letters, primary first.	required

Returns:

Type	Description
str | None	str | None: The problem, in words.

Source code in src/solidworks_mcp/adapters/solidworks/drawing_standard.py

def gtol_problem(
    characteristic: str,
    tolerance: float,
    material_condition: str,
    datums: list[str] | None,
) -> str | None:
    """Why a feature control frame's inputs are invalid, or ``None`` when valid.

    Shared by the real and mock adapters so both refuse the same inputs.

    Args:
        characteristic: The GD&T characteristic name.
        tolerance: The tolerance value.
        material_condition: ``none``, ``mmc`` or ``lmc``.
        datums: Datum letters, primary first.

    Returns:
        str | None: The problem, in words.
    """
    letters = [d.strip() for d in datums or []]
    if characteristic not in _GTOL_SYMBOLS:
        return f"characteristic must be one of {', '.join(_GTOL_SYMBOLS)}"
    if material_condition not in _GTOL_MODIFIERS:
        return f"material_condition must be one of {', '.join(_GTOL_MODIFIERS)}"
    if tolerance <= 0:
        return "tolerance must be positive"
    if len(letters) > 3 or any(len(d) != 1 or not d.isalpha() for d in letters):
        return "at most three datums, each a single letter"
    return None