Skip to content

solidworks_mcp.adapters.factory

solidworks_mcp.adapters.factory

Adapter factory for creating SolidWorks adapters.

Provides centralized adapter creation with configuration-based selection and automatic fallback strategies.

Classes

AdapterFactory

Factory-pattern adapter creator with singleton and fallback strategies.

Manages adapter registration and creation with configuration-based selection. Automatically wraps adapters with decorators (circuit breaker, connection pool) based on configuration. Implements singleton pattern for consistency.

Attributes:

Name Type Description
_adapter_registry dict[AdapterType, type[SolidWorksAdapter]]

The adapter registry value.
_adapters dict[AdapterType, type[SolidWorksAdapter]]

The adapters value.
_instance AdapterFactory | None

The instance value.
Example

factory = AdapterFactory() config = SolidWorksMCPConfig(adapter_type=AdapterType.PYWIN32) adapter = factory.create_adapter(config) await adapter.connect()

Functions
__new__ 
__new__() -> AdapterFactory

Initialize or return singleton AdapterFactory instance.

Enforces singleton pattern to ensure single adapter registry and consistent factory behavior across application lifetime.

Returns:

Name Type Description
AdapterFactory AdapterFactory

The result produced by the operation.
Example

factory1 = AdapterFactory() factory2 = AdapterFactory() factory1 is factory2 True

Source code in src/solidworks_mcp/adapters/factory.py 
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def __new__(cls) -> AdapterFactory:
    """Initialize or return singleton AdapterFactory instance.

    Enforces singleton pattern to ensure single adapter registry and consistent factory
    behavior across application lifetime.

    Returns:
        AdapterFactory: The result produced by the operation.

    Example:
                        >>> factory1 = AdapterFactory()
                        >>> factory2 = AdapterFactory()
                        >>> factory1 is factory2
                        True
    """
    if cls._instance is None:
        cls._instance = super().__new__(cls)
    return cls._instance
create_adapter classmethod 
create_adapter(config: SolidWorksMCPConfig) -> SolidWorksAdapter

Create and configure a SolidWorks adapter instance.

Determines the best adapter type based on configuration and environment. Selects implementation, applies wrappers (circuit breaker, connection pool), and returns a fully-initialized adapter ready for connection.

The adapter is automatically downgraded to Mock on non-Windows platforms or when testing is enabled, with fallback to configured type otherwise.

Parameters:

Name Type Description Default
config SolidWorksMCPConfig

Configuration values for the operation.

 required

Returns:

Name Type Description
SolidWorksAdapter SolidWorksAdapter

The result produced by the operation.
Example

config = SolidWorksMCPConfig(mock_solidworks=True) adapter = AdapterFactory.create_adapter(config) isinstance(adapter, MockSolidWorksAdapter) True

Source code in src/solidworks_mcp/adapters/factory.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
@classmethod
def create_adapter(cls, config: SolidWorksMCPConfig) -> SolidWorksAdapter:
    """Create and configure a SolidWorks adapter instance.

    Determines the best adapter type based on configuration and environment. Selects
    implementation, applies wrappers (circuit breaker, connection pool), and returns a
    fully-initialized adapter ready for connection.

    The adapter is automatically downgraded to Mock on non-Windows platforms or when testing
    is enabled, with fallback to configured type otherwise.

    Args:
        config (SolidWorksMCPConfig): Configuration values for the operation.

    Returns:
        SolidWorksAdapter: The result produced by the operation.

    Example:
                        >>> config = SolidWorksMCPConfig(mock_solidworks=True)
                        >>> adapter = AdapterFactory.create_adapter(config)
                        >>> isinstance(adapter, MockSolidWorksAdapter)
                        True
    """
    factory = cls()
    return factory._create_adapter_impl(config)
register_adapter classmethod 
register_adapter(adapter_type: AdapterType, adapter_class: type[SolidWorksAdapter]) -> None

Register an adapter class for a given adapter type.

Updates the adapter registry to map a specific AdapterType enum value to a SolidWorksAdapter implementation class. Called during initialization to register built- in adapters (PyWin32, Mock, etc.).

Parameters:

Name Type Description Default
adapter_type AdapterType

The adapter type value.

 required
adapter_class type[SolidWorksAdapter]

The adapter class value.

 required

Returns:

Name Type Description
None None

None.
Example

from adapters.pywin32_adapter import PyWin32Adapter AdapterFactory.register_adapter( ... AdapterType.PYWIN32, PyWin32Adapter ... )

Source code in src/solidworks_mcp/adapters/factory.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
@classmethod
def register_adapter(
    cls, adapter_type: AdapterType, adapter_class: type[SolidWorksAdapter]
) -> None:
    """Register an adapter class for a given adapter type.

    Updates the adapter registry to map a specific AdapterType enum value to a
    SolidWorksAdapter implementation class. Called during initialization to register built-
    in adapters (PyWin32, Mock, etc.).

    Args:
        adapter_type (AdapterType): The adapter type value.
        adapter_class (type[SolidWorksAdapter]): The adapter class value.

    Returns:
        None: None.

    Example:
                        >>> from adapters.pywin32_adapter import PyWin32Adapter
                        >>> AdapterFactory.register_adapter(
                        ...     AdapterType.PYWIN32, PyWin32Adapter
                        ... )
    """
    cls._adapter_registry[adapter_type] = adapter_class

AdapterType

Bases: StrEnum

SolidWorks adapter implementation options.

Attributes:

Name Type Description
EDGE_DOTNET Any

The edge dotnet value.
MOCK Any

The mock value.
POWERSHELL Any

The powershell value.
PYWIN32 Any

The pywin32 value.
VBA Any

The vba 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 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
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: SolidWorksModel | None = None
    self._models: dict[str, SolidWorksModel] = {}
    self._features: dict[str, SolidWorksFeature] = {}
    self._sketches: dict[str, str] = {}
    self._current_sketch: str | None = None
    # 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] = {}
    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))
Functions
__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 
121
122
123
124
125
126
127
128
129
130
131
132
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)
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 
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
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 
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
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_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 
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
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_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 
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
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_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 
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
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_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 
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
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 
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
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 
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
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 
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
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 
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
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,
    )
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 
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
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 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
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 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
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) -> AdapterResult[SolidWorksModel]

Mock creating a new assembly.

Parameters:

Name Type Description Default
name str | None

The name value. 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 
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
async def create_assembly(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new assembly.

    Args:
        name (str | None): The name value. 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},
    )

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )
create_drawing async 
create_drawing(name: 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

Returns:

Type Description
AdapterResult[SolidWorksModel]

AdapterResult[SolidWorksModel]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
async def create_drawing(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Mock creating a new drawing.

    Args:
        name (str | None): The name value. 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},
    )

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )
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 
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
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)

    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,
            "thin_feature": params.thin_feature,
            "thin_thickness": params.thin_thickness,
        },
        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 
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
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) -> 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

Returns:

Type Description
AdapterResult[SolidWorksModel]

AdapterResult[SolidWorksModel]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
async def create_part(
    self, name: str | None = None, units: 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.

    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"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": units or "mm",
        },
    )

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_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 
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
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"
        )

    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,
        },
        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 
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
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_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 
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
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"],
    )
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 
150
151
152
153
154
155
156
157
158
159
160
161
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
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 
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
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 
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
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_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 
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
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_dimension async 
get_dimension(name: str) -> AdapterResult[float]

Mock getting a dimension value.

Parameters:

Name Type Description Default
name str

The name value.

 required

Returns:

Type Description
AdapterResult[float]

AdapterResult[float]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
async def get_dimension(self, name: str) -> AdapterResult[float]:
    """Mock getting a dimension value.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[float]: The result produced by the operation.
    """
    await asyncio.sleep(0.05)  # Very fast operation
    self._operation_count += 1

    if name in self._dimensions:
        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data=self._dimensions[name],
            execution_time=0.05,
        )
    else:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error=f"Dimension '{name}' not found"
        )
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 
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
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_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 
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
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,
    )
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 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
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),
        },
    )
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 
163
164
165
166
167
168
169
def is_connected(self) -> bool:
    """Check if mock connection is active.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self._connected
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 
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
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_features async 
list_features(include_suppressed: bool = False) -> AdapterResult[list[dict[str, Any]]]

Mock feature tree listing for the active model.

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False.

 False

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 
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
async def list_features(
    self, include_suppressed: bool = False
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock feature tree listing for the active model.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.

    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

    # Seed realistic feature names for empty mock state.
    if not self._features:
        seeded = [
            {"name": "Origin", "type": "OriginProfileFeature", "suppressed": False},
            {"name": "Front Plane", "type": "RefPlane", "suppressed": False},
            {"name": "Right Plane", "type": "RefPlane", "suppressed": False},
            {"name": "Top Plane", "type": "RefPlane", "suppressed": False},
            {"name": "Sketch1", "type": "ProfileFeature", "suppressed": False},
        ]
        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,
        }
        if include_suppressed or not row["suppressed"]:
            feature_rows.append(row)

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature_rows,
        execution_time=self._delays["feature_operation"] / 2,
    )
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 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
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"],
    )
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 
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
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_feature async 
select_feature(feature_name: str) -> AdapterResult[dict[str, Any]]

Mock feature selection/highlight — succeeds without COM side-effects.

Parameters:

Name Type Description Default
feature_name str

The feature name 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 
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
async def select_feature(self, feature_name: str) -> AdapterResult[dict[str, Any]]:
    """Mock feature selection/highlight — succeeds without COM side-effects.

    Args:
        feature_name (str): The feature name value.

    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
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "selected": True,
            "feature_name": feature_name,
            "entity_type": "mock",
        },
        execution_time=self._delays["feature_operation"] / 4,
    )
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 
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
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
    )
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 
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
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 
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
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 
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
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 
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
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,
    )

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 
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
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,
    }
Functions
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 
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
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 
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
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_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 
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
@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_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 
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
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 
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
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_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 
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
@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_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 
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
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 
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
@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 
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
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 
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
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 
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
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 
642
643
644
645
646
647
648
649
650
651
652
653
654
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",
    )
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 
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
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 
394
395
396
397
398
399
400
401
402
403
404
@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 
345
346
347
348
349
350
351
352
@abstractmethod
async def connect(self) -> None:
    """Connect to SolidWorks application.

    Returns:
        None: None.
    """
    pass
create_assembly abstractmethod async 
create_assembly(name: 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

Returns:

Type Description
AdapterResult[SolidWorksModel]

AdapterResult[SolidWorksModel]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
467
468
469
470
471
472
473
474
475
476
477
478
479
@abstractmethod
async def create_assembly(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new assembly document.

    Args:
        name (str | None): The name value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass
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 
890
891
892
893
894
895
896
897
898
899
900
901
902
903
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 
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
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) -> AdapterResult[SolidWorksModel]

Create a new drawing document.

Parameters:

Name Type Description Default
name str | None

The name value. 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 
481
482
483
484
485
486
487
488
489
490
491
492
493
@abstractmethod
async def create_drawing(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create a new drawing document.

    Args:
        name (str | None): The name value. Defaults to None.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass
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 
496
497
498
499
500
501
502
503
504
505
506
507
508
@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 
538
539
540
541
542
543
544
545
546
547
548
549
550
@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) -> 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

Returns:

Type Description
AdapterResult[SolidWorksModel]

AdapterResult[SolidWorksModel]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
452
453
454
455
456
457
458
459
460
461
462
463
464
465
@abstractmethod
async def create_part(
    self, name: str | None = None, units: 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.

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    pass
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 
510
511
512
513
514
515
516
517
518
519
520
521
522
@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 
553
554
555
556
557
558
559
560
561
562
563
@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_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 
524
525
526
527
528
529
530
531
532
533
534
535
536
@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
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 
354
355
356
357
358
359
360
361
@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 
943
944
945
946
947
948
949
950
@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 
979
980
981
982
983
984
985
986
987
988
989
990
991
992
@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_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 
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
@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_dimension abstractmethod async 
get_dimension(name: str) -> AdapterResult[float]

Get the value of a dimension.

Parameters:

Name Type Description Default
name str

The name value.

 required

Returns:

Type Description
AdapterResult[float]

AdapterResult[float]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
@abstractmethod
async def get_dimension(self, name: str) -> AdapterResult[float]:
    """Get the value of a dimension.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[float]: The result produced by the operation.
    """
    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 
953
954
955
956
957
958
959
960
@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_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 
1042
1043
1044
1045
1046
1047
1048
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_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 
420
421
422
423
424
425
426
427
@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
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 
372
373
374
375
376
377
378
379
@abstractmethod
async def health_check(self) -> AdapterHealth:
    """Get adapter health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    pass
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 
363
364
365
366
367
368
369
370
@abstractmethod
def is_connected(self) -> bool:
    """Check if connected to SolidWorks.

    Returns:
        bool: True if connected, otherwise False.
    """
    pass
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 
443
444
445
446
447
448
449
450
@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_features abstractmethod async 
list_features(include_suppressed: bool = False) -> AdapterResult[list[dict[str, Any]]]

List model features from the feature tree.

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False.

 False

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 
429
430
431
432
433
434
435
436
437
438
439
440
441
@abstractmethod
async def list_features(
    self, include_suppressed: bool = False
) -> AdapterResult[list[dict[str, Any]]]:
    """List model features from the feature tree.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    pass
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 
382
383
384
385
386
387
388
389
390
391
392
@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
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 
406
407
408
409
410
411
412
413
414
415
416
417
418
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",
    )
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 
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
@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
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 
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
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 
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
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 
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
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 
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
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",
    )
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 
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
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

SolidWorksMCPConfig

Bases: BaseModel

Main configuration for SolidWorks MCP Server.

Attributes:

Name Type Description
adapter_type AdapterType

The adapter type value.
allowed_hosts list[str]

The allowed hosts value.
allowed_origins list[str]

The allowed origins value.
api_key SecretStr | None

The api key value.
api_key_required bool

The api key required value.
api_keys list[str]

The api keys value.
cache_dir Path | None

The cache dir value.
circuit_breaker_enabled bool

The circuit breaker enabled value.
circuit_breaker_threshold int

The circuit breaker threshold value.
circuit_breaker_timeout int

The circuit breaker timeout value.
complexity_parameter_threshold int

The complexity parameter threshold value.
complexity_score_threshold float

The complexity score threshold value.
connection_pool_size int

The connection pool size value.
connection_pooling bool

The connection pooling value.
cors_origins list[str]

The cors origins value.
data_dir Path

The data dir value.
database_url str

The database url value.
debug bool

The debug value.
deployment_mode DeploymentMode

The deployment mode value.
enable_analysis_tools bool

The enable analysis tools value.
enable_audit_logging bool

The enable audit logging value.
enable_circuit_breaker bool

The enable circuit breaker value.
enable_connection_pooling bool

The enable connection pooling value.
enable_cors bool

The enable cors value.
enable_design_tables bool

The enable design tables value.
enable_intelligent_routing bool

The enable intelligent routing value.
enable_macro_recording bool

The enable macro recording value.
enable_pdm bool

The enable pdm value.
enable_rate_limiting bool

The enable rate limiting value.
enable_response_cache bool

The enable response cache value.
enable_sql_integration bool

The enable sql integration value.
enable_windows_validation bool

The enable windows validation value.
host str

The host value.
log_file Path | None

The log file value.
log_level str

The log level value.
max_connections int

The max connections value.
max_retries int

The max retries value.
mock_solidworks bool

The mock solidworks value.
model_config Any

The model config value.
pdm_server str | None

The pdm server value.
pdm_vault str | None

The pdm vault value.
port int

The port value.
rate_limit_enabled bool

The rate limit enabled value.
rate_limit_per_minute int

The rate limit per minute value.
response_cache_max_entries int

The response cache max entries value.
response_cache_ttl_seconds int

The response cache ttl seconds value.
security_level SecurityLevel

The security level value.
solidworks_path str | None

The solidworks path value.
solidworks_year int | None

The solidworks year value.
sql_connection str | None

The sql connection value.
state_file str | None

The state file value.
testing bool

The testing value.
timeout_seconds float

The timeout seconds value.
worker_processes int

The worker processes value.
Attributes
can_use_solidworks property 
can_use_solidworks: bool

Check if SolidWorks integration is possible.

Returns:

Name Type Description
bool bool

True if use solidworks, otherwise False.
is_windows property 
is_windows: bool

Check if running on Windows.

Returns:

Name Type Description
bool bool

True if windows, otherwise False.
Functions
from_env classmethod 
from_env(env_file: str | None = None) -> SolidWorksMCPConfig

Build configuration from environment variables.

Parameters:

Name Type Description Default
env_file str | None

The env file value. Defaults to None.

 None

Returns:

Name Type Description
SolidWorksMCPConfig SolidWorksMCPConfig

The result produced by the operation.
Source code in src/solidworks_mcp/config.py 
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
@classmethod
def from_env(cls, env_file: str | None = None) -> SolidWorksMCPConfig:
    """Build configuration from environment variables.

    Args:
        env_file (str | None): The env file value. Defaults to None.

    Returns:
        SolidWorksMCPConfig: The result produced by the operation.
    """
    import json

    env_prefix = "SOLIDWORKS_MCP_"
    raw_values: dict[str, Any] = {}

    list_like_fields = {"cors_origins", "allowed_hosts", "api_keys"}

    def _coerce_env_value(key: str, value: Any) -> Any:
        """Build internal coerce env value.

        Args:
            key (str): The key value.
            value (Any): The value value.

        Returns:
            Any: The result produced by the operation.
        """
        if not isinstance(value, str):
            return value
        if key in list_like_fields:
            stripped = value.strip()
            if stripped.startswith("[") and stripped.endswith("]"):
                try:
                    parsed = json.loads(stripped)
                    if isinstance(parsed, list):
                        return parsed
                except Exception:
                    # Leave original value for Pydantic to validate/report.
                    return value
        return value

    if env_file and Path(env_file).exists():
        for key, value in dotenv_values(env_file).items():
            if key and key.startswith(env_prefix) and value is not None:
                field_name = key[len(env_prefix) :].lower()
                raw_values[field_name] = _coerce_env_value(field_name, value)

    for key, value in os.environ.items():
        if key.startswith(env_prefix):
            field_name = key[len(env_prefix) :].lower()
            raw_values[field_name] = _coerce_env_value(field_name, value)

    return cls(**raw_values)
get_database_config 
get_database_config() -> dict[str, Any]

Get database configuration.

Returns:

Type Description
dict[str, Any]

dict[str, Any]: A dictionary containing the resulting values.
Source code in src/solidworks_mcp/config.py 
637
638
639
640
641
642
643
644
645
646
def get_database_config(self) -> dict[str, Any]:
    """Get database configuration.

    Returns:
        dict[str, Any]: A dictionary containing the resulting values.
    """
    return {
        "url": self.database_url,
        "echo": self.debug,
    }
get_security_config 
get_security_config() -> dict[str, Any]

Get security configuration.

Returns:

Type Description
dict[str, Any]

dict[str, Any]: A dictionary containing the resulting values.
Source code in src/solidworks_mcp/config.py 
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
def get_security_config(self) -> dict[str, Any]:
    """Get security configuration.

    Returns:
        dict[str, Any]: A dictionary containing the resulting values.
    """
    return {
        "api_key": self.api_key.get_secret_value() if self.api_key else None,
        "allowed_hosts": self.allowed_hosts,
        "enable_cors": self.enable_cors,
        "cors_origins": self.cors_origins,
        "enable_rate_limiting": self.enable_rate_limiting,
        "rate_limit_per_minute": self.rate_limit_per_minute,
        "security_level": self.security_level,
    }
model_post_init 
model_post_init(__context: Any) -> None

Post-initialization setup.

Parameters:

Name Type Description Default
__context Any

The context value.

 required

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/config.py 
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
def model_post_init(self, __context: Any) -> None:
    """Post-initialization setup.

    Args:
        __context (Any): The context value.

    Returns:
        None: None.
    """
    if self.cache_dir is None:
        self.cache_dir = self.data_dir / "cache"
    if self.log_file is None:
        self.log_file = self.data_dir / "logs" / "server.log"

    # Ensure data directories exist
    self.data_dir.mkdir(parents=True, exist_ok=True)
    self.cache_dir.mkdir(parents=True, exist_ok=True)
    self.log_file.parent.mkdir(parents=True, exist_ok=True)

    # Set testing defaults
    if self.testing:
        self.mock_solidworks = True
        self.adapter_type = AdapterType.MOCK
set_cache_dir classmethod 
set_cache_dir(v: Path | None, info: ValidationInfo) -> Path

Set default cache directory.

Parameters:

Name Type Description Default
v Path | None

The v value.

 required
info ValidationInfo

The info value.

 required

Returns:

Name Type Description
Path Path

The result produced by the operation.
Source code in src/solidworks_mcp/config.py 
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
@field_validator("cache_dir")
@classmethod
def set_cache_dir(cls, v: Path | None, info: ValidationInfo) -> Path:
    """Set default cache directory.

    Args:
        v (Path | None): The v value.
        info (ValidationInfo): The info value.

    Returns:
        Path: The result produced by the operation.
    """
    if v is None:
        data_dir = cast(
            Path,
            info.data.get("data_dir", Path.home() / ".solidworks_mcp"),
        )
        return data_dir / "cache"
    return v
set_log_file classmethod 
set_log_file(v: Path | None, info: ValidationInfo) -> Path

Set default log file path.

Parameters:

Name Type Description Default
v Path | None

The v value.

 required
info ValidationInfo

The info value.

 required

Returns:

Name Type Description
Path Path

The result produced by the operation.
Source code in src/solidworks_mcp/config.py 
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
@field_validator("log_file")
@classmethod
def set_log_file(cls, v: Path | None, info: ValidationInfo) -> Path:
    """Set default log file path.

    Args:
        v (Path | None): The v value.
        info (ValidationInfo): The info value.

    Returns:
        Path: The result produced by the operation.
    """
    if v is None:
        data_dir = cast(
            Path,
            info.data.get("data_dir", Path.home() / ".solidworks_mcp"),
        )
        return data_dir / "logs" / "server.log"
    return v
sync_legacy_alias_fields 
sync_legacy_alias_fields() -> SolidWorksMCPConfig

Sync test/developer alias fields into canonical runtime fields.

Several fixtures and scripts still populate compatibility fields such as rate_limit_enabled and connection_pooling. Runtime code reads the canonical fields, so normalize them here after validation.

Returns:

Name Type Description
SolidWorksMCPConfig SolidWorksMCPConfig

The result produced by the operation.
Source code in src/solidworks_mcp/config.py 
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
@model_validator(mode="after")
def sync_legacy_alias_fields(self) -> SolidWorksMCPConfig:
    """Sync test/developer alias fields into canonical runtime fields.

    Several fixtures and scripts still populate compatibility fields such as
    ``rate_limit_enabled`` and ``connection_pooling``. Runtime code reads the canonical
    fields, so normalize them here after validation.

    Returns:
        SolidWorksMCPConfig: The result produced by the operation.
    """
    self.enable_circuit_breaker = self.circuit_breaker_enabled
    self.enable_connection_pooling = self.connection_pooling
    self.connection_pool_size = self.max_connections
    self.enable_rate_limiting = self.rate_limit_enabled
    if self.allowed_origins and not self.cors_origins:
        self.cors_origins = list(self.allowed_origins)
    return self
validate_adapter_type classmethod 
validate_adapter_type(v: AdapterType, info: ValidationInfo) -> AdapterType

Validate adapter type based on platform.

Parameters:

Name Type Description Default
v AdapterType

The v value.

 required
info ValidationInfo

The info value.

 required

Returns:

Name Type Description
AdapterType AdapterType

The result produced by the operation.
Source code in src/solidworks_mcp/config.py 
415
416
417
418
419
420
421
422
423
424
425
426
427
@field_validator("adapter_type")
@classmethod
def validate_adapter_type(cls, v: AdapterType, info: ValidationInfo) -> AdapterType:
    """Validate adapter type based on platform.

    Args:
        v (AdapterType): The v value.
        info (ValidationInfo): The info value.

    Returns:
        AdapterType: The result produced by the operation.
    """
    return v
validate_complexity_parameter_threshold classmethod 
validate_complexity_parameter_threshold(v: int) -> int

Validate the complexity parameter threshold.

Parameters:

Name Type Description Default
v int

The v value.

 required

Returns:

Name Type Description
int int

The computed numeric result.

Raises:

Type Description
ValueError

Complexity_parameter_threshold must be >= 1.
Source code in src/solidworks_mcp/config.py 
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
@field_validator("complexity_parameter_threshold")
@classmethod
def validate_complexity_parameter_threshold(cls, v: int) -> int:
    """Validate the complexity parameter threshold.

    Args:
        v (int): The v value.

    Returns:
        int: The computed numeric result.

    Raises:
        ValueError: Complexity_parameter_threshold must be >= 1.
    """
    if v < 1:
        raise ValueError("complexity_parameter_threshold must be >= 1")
    return v
validate_complexity_score_threshold classmethod 
validate_complexity_score_threshold(v: float) -> float

Validate the complexity score threshold.

Parameters:

Name Type Description Default
v float

The v value.

 required

Returns:

Name Type Description
float float

The computed numeric result.

Raises:

Type Description
ValueError

Complexity_score_threshold must be in (0, 1].
Source code in src/solidworks_mcp/config.py 
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
@field_validator("complexity_score_threshold")
@classmethod
def validate_complexity_score_threshold(cls, v: float) -> float:
    """Validate the complexity score threshold.

    Args:
        v (float): The v value.

    Returns:
        float: The computed numeric result.

    Raises:
        ValueError: Complexity_score_threshold must be in (0, 1].
    """
    if v <= 0 or v > 1:
        raise ValueError("complexity_score_threshold must be in (0, 1]")
    return v
validate_port classmethod 
validate_port(v: int) -> int

Validate the port.

Parameters:

Name Type Description Default
v int

The v value.

 required

Returns:

Name Type Description
int int

The computed numeric result.

Raises:

Type Description
ValueError

Port must be between 1 and 65535.
Source code in src/solidworks_mcp/config.py 
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
@field_validator("port")
@classmethod
def validate_port(cls, v: int) -> int:
    """Validate the port.

    Args:
        v (int): The v value.

    Returns:
        int: The computed numeric result.

    Raises:
        ValueError: Port must be between 1 and 65535.
    """
    if v < 1 or v > 65535:
        raise ValueError("Port must be between 1 and 65535")
    return v
validate_response_cache_max_entries classmethod 
validate_response_cache_max_entries(v: int) -> int

Validate response cache size.

Parameters:

Name Type Description Default
v int

The v value.

 required

Returns:

Name Type Description
int int

The computed numeric result.

Raises:

Type Description
ValueError

Response_cache_max_entries must be >= 1.
Source code in src/solidworks_mcp/config.py 
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
@field_validator("response_cache_max_entries")
@classmethod
def validate_response_cache_max_entries(cls, v: int) -> int:
    """Validate response cache size.

    Args:
        v (int): The v value.

    Returns:
        int: The computed numeric result.

    Raises:
        ValueError: Response_cache_max_entries must be >= 1.
    """
    if v < 1:
        raise ValueError("response_cache_max_entries must be >= 1")
    return v
validate_response_cache_ttl_seconds classmethod 
validate_response_cache_ttl_seconds(v: int) -> int

Validate default response cache TTL.

Parameters:

Name Type Description Default
v int

The v value.

 required

Returns:

Name Type Description
int int

The computed numeric result.

Raises:

Type Description
ValueError

Response_cache_ttl_seconds must be >= 1.
Source code in src/solidworks_mcp/config.py 
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
@field_validator("response_cache_ttl_seconds")
@classmethod
def validate_response_cache_ttl_seconds(cls, v: int) -> int:
    """Validate default response cache TTL.

    Args:
        v (int): The v value.

    Returns:
        int: The computed numeric result.

    Raises:
        ValueError: Response_cache_ttl_seconds must be >= 1.
    """
    if v < 1:
        raise ValueError("response_cache_ttl_seconds must be >= 1")
    return v
validate_timeout classmethod 
validate_timeout(v: float) -> float

Validate the timeout.

Parameters:

Name Type Description Default
v float

The v value.

 required

Returns:

Name Type Description
float float

The computed numeric result.

Raises:

Type Description
ValueError

Timeout_seconds must be > 0.
Source code in src/solidworks_mcp/config.py 
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
@field_validator("timeout_seconds")
@classmethod
def validate_timeout(cls, v: float) -> float:
    """Validate the timeout.

    Args:
        v (float): The v value.

    Returns:
        float: The computed numeric result.

    Raises:
        ValueError: Timeout_seconds must be > 0.
    """
    if v <= 0:
        raise ValueError("timeout_seconds must be > 0")
    return v

VbaGeneratorAdapter 

VbaGeneratorAdapter(backing_adapter: Any, macro_executor: VbaMacroExecutor | None = None)

Adapter that executes complex operations through VBA-oriented flow.

This adapter currently uses the wrapped COM adapter for final execution, but annotates responses as VBA-routed and can be extended to execute generated macros directly in future iterations.

Parameters:

Name Type Description Default
backing_adapter Any

The backing adapter value.

 required
macro_executor VbaMacroExecutor | None

The macro executor value. Defaults to None.

 None

Attributes:

Name Type Description
_backing_adapter Any

The backing adapter value.
_macro_executor Any

The macro executor value.
config Any

The config value.

Initialize the vba generator adapter.

Parameters:

Name Type Description Default
backing_adapter Any

The backing adapter value.

 required
macro_executor VbaMacroExecutor | None

The macro executor value. Defaults to None.

 None

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
def __init__(
    self,
    backing_adapter: Any,
    macro_executor: VbaMacroExecutor | None = None,
) -> None:
    """Initialize the vba generator adapter.

    Args:
        backing_adapter (Any): The backing adapter value.
        macro_executor (VbaMacroExecutor | None): The macro executor value. Defaults to
                                                  None.

    Returns:
        None: None.
    """
    self._backing_adapter = backing_adapter
    self._macro_executor = macro_executor or VbaMacroExecutor()
    self.config = getattr(backing_adapter, "config", None)
Functions
__getattr__ 
__getattr__(item: str) -> Any

Delegate unknown members to backing adapter.

Parameters:

Name Type Description Default
item str

The item value.

 required

Returns:

Name Type Description
Any Any

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
55
56
57
58
59
60
61
62
63
64
def __getattr__(self, item: str) -> Any:
    """Delegate unknown members to backing adapter.

    Args:
        item (str): The item value.

    Returns:
        Any: The result produced by the operation.
    """
    return getattr(self._backing_adapter, item)
connect async 
connect() -> None

Connect to SolidWorks using wrapped adapter.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
66
67
68
69
70
71
72
async def connect(self) -> None:
    """Connect to SolidWorks using wrapped adapter.

    Returns:
        None: None.
    """
    await self._backing_adapter.connect()
create_extrusion async 
create_extrusion(params: ExtrusionParameters) -> AdapterResult[Any]

Create the extrusion.

Parameters:

Name Type Description Default
params ExtrusionParameters

The params value.

 required

Returns:

Type Description
AdapterResult[Any]

AdapterResult[Any]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
async def create_extrusion(
    self,
    params: ExtrusionParameters,
) -> AdapterResult[Any]:
    """Create the extrusion.

    Args:
        params (ExtrusionParameters): The params value.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return await self._run_with_vba_metadata(
        operation="create_extrusion",
        payload=params,
        com_call=self._backing_adapter.create_extrusion,
        vba_code=self._generate_extrusion_vba(params),
    )
create_loft async 
create_loft(params: LoftParameters) -> AdapterResult[Any]

Create the loft.

Parameters:

Name Type Description Default
params LoftParameters

The params value.

 required

Returns:

Type Description
AdapterResult[Any]

AdapterResult[Any]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
async def create_loft(
    self,
    params: LoftParameters,
) -> AdapterResult[Any]:
    """Create the loft.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return await self._run_with_vba_metadata(
        operation="create_loft",
        payload=params,
        com_call=self._backing_adapter.create_loft,
        vba_code=self._generate_loft_vba(params),
    )
create_revolve async 
create_revolve(params: RevolveParameters) -> AdapterResult[Any]

Create the revolve.

Parameters:

Name Type Description Default
params RevolveParameters

The params value.

 required

Returns:

Type Description
AdapterResult[Any]

AdapterResult[Any]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
async def create_revolve(
    self,
    params: RevolveParameters,
) -> AdapterResult[Any]:
    """Create the revolve.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return await self._run_with_vba_metadata(
        operation="create_revolve",
        payload=params,
        com_call=self._backing_adapter.create_revolve,
        vba_code=self._generate_revolve_vba(params),
    )
create_sweep async 
create_sweep(params: SweepParameters) -> AdapterResult[Any]

Create the sweep.

Parameters:

Name Type Description Default
params SweepParameters

The params value.

 required

Returns:

Type Description
AdapterResult[Any]

AdapterResult[Any]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
async def create_sweep(
    self,
    params: SweepParameters,
) -> AdapterResult[Any]:
    """Create the sweep.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    return await self._run_with_vba_metadata(
        operation="create_sweep",
        payload=params,
        com_call=self._backing_adapter.create_sweep,
        vba_code=self._generate_sweep_vba(params),
    )
disconnect async 
disconnect() -> None

Disconnect wrapped adapter.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
74
75
76
77
78
79
80
async def disconnect(self) -> None:
    """Disconnect wrapped adapter.

    Returns:
        None: None.
    """
    await self._backing_adapter.disconnect()
execute_macro async 
execute_macro(macro_code: str, macro_name: str = 'GeneratedMacro', subroutine: str = 'Main') -> AdapterResult[Any]

Provide execute macro support for the vba generator adapter.

Parameters:

Name Type Description Default
macro_code str

The macro code value.

 required
macro_name str

The macro name value. Defaults to "GeneratedMacro".

 'GeneratedMacro'
subroutine str

The subroutine value. Defaults to "Main".

 'Main'

Returns:

Type Description
AdapterResult[Any]

AdapterResult[Any]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
async def execute_macro(
    self,
    macro_code: str,
    macro_name: str = "GeneratedMacro",
    subroutine: str = "Main",
) -> AdapterResult[Any]:
    """Provide execute macro support for the vba generator adapter.

    Args:
        macro_code (str): The macro code value.
        macro_name (str): The macro name value. Defaults to "GeneratedMacro".
        subroutine (str): The subroutine value. Defaults to "Main".

    Returns:
        AdapterResult[Any]: The result produced by the operation.
    """
    request = MacroExecutionRequest(
        macro_code=macro_code,
        macro_name=macro_name,
        subroutine=subroutine,
    )
    return await self._macro_executor.execute_macro(
        request=request,
        backing_adapter=self._backing_adapter,
    )
get_macro_execution_history 
get_macro_execution_history(macro_name: str | None = None) -> dict[str, Any]

Retrieve VBA macro execution history.

Parameters:

Name Type Description Default
macro_name str | None

The macro name value. Defaults to None.

 None

Returns:

Type Description
dict[str, Any]

dict[ str, Any,
dict[str, Any]

]: A dictionary containing the resulting values.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
def get_macro_execution_history(
    self, macro_name: str | None = None
) -> dict[
    str,
    Any,
]:
    """Retrieve VBA macro execution history.

    Args:
        macro_name (str | None): The macro name value. Defaults to None.

    Returns:
        dict[
            str,
            Any,
        ]: A dictionary containing the resulting values.
    """
    history = self._macro_executor.get_execution_history(macro_name)
    return {key: value.__dict__ for key, value in history.items()}
health_check async 
health_check() -> Any

Return wrapped adapter health with VBA route marker.

Returns:

Name Type Description
Any Any

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
async def health_check(self) -> Any:
    """Return wrapped adapter health with VBA route marker.

    Returns:
        Any: The result produced by the operation.
    """
    health = await self._backing_adapter.health_check()
    if hasattr(health, "metrics"):
        metrics = dict(health.metrics or {})
        metrics["route"] = "vba"
        health.metrics = metrics
    return health
is_connected 
is_connected() -> bool

Return wrapped adapter connection state.

Returns:

Name Type Description
bool bool

True if connected, otherwise False.
Source code in src/solidworks_mcp/adapters/vba_adapter.py 
82
83
84
85
86
87
88
def is_connected(self) -> bool:
    """Return wrapped adapter connection state.

    Returns:
        bool: True if connected, otherwise False.
    """
    return bool(self._backing_adapter.is_connected())

Functions

_register_default_adapters 

_register_default_adapters() -> None

Register default adapter implementations.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/factory.py 
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
def _register_default_adapters() -> None:
    """Register default adapter implementations.

    Returns:
        None: None.
    """
    # Always register mock adapter
    AdapterFactory.register_adapter(AdapterType.MOCK, MockSolidWorksAdapter)
    AdapterFactory.register_adapter(AdapterType.VBA, VbaGeneratorAdapter)  # type: ignore[arg-type]

    # Register pywin32 adapter if on Windows
    if platform.system() == "Windows":
        try:
            from .pywin32_adapter import PyWin32Adapter

            AdapterFactory.register_adapter(AdapterType.PYWIN32, PyWin32Adapter)
        except ImportError:
            # pywin32 not available, will fall back to mock
            pass

create_adapter async 

create_adapter(config: SolidWorksMCPConfig) -> SolidWorksAdapter

Async factory function for creating SolidWorks adapters.

Parameters:

Name Type Description Default
config SolidWorksMCPConfig

Configuration values for the operation.

 required

Returns:

Name Type Description
SolidWorksAdapter SolidWorksAdapter

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/factory.py 
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
async def create_adapter(config: SolidWorksMCPConfig) -> SolidWorksAdapter:
    """Async factory function for creating SolidWorks adapters.

    Args:
        config (SolidWorksMCPConfig): Configuration values for the operation.

    Returns:
        SolidWorksAdapter: The result produced by the operation.
    """
    # Register adapters if not already done
    _register_default_adapters()

    # Create adapter using factory
    adapter = AdapterFactory.create_adapter(config)

    return adapter