Skip to content

solidworks_mcp.adapters

solidworks_mcp.adapters

SolidWorks adapter interfaces and factory.

This module provides the adapter pattern infrastructure for different SolidWorks integration approaches (pywin32, mock, future edge.js, etc.)

Attributes

__all__ module-attribute 

__all__ = ['SolidWorksAdapter', 'AdapterResult', 'AdapterHealth', 'create_adapter', 'AdapterType', 'AdapterFactory', 'PyWin32Adapter', 'MockSolidWorksAdapter', 'CircuitBreakerAdapter', 'ConnectionPoolAdapter', 'ComplexityAnalyzer', 'RoutingDecision', 'IntelligentRouter', 'VbaGeneratorAdapter', 'VbaMacroExecutor', 'MacroExecutionRequest', 'MacroExecutionResult']

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()

Methods:
__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

AdapterHealth

Bases: BaseModel

Health status information for adapters.

Attributes:

Name Type Description
average_response_time float

The average response time value.
connection_status str

The connection status value.
error_count int

The error count value.
healthy bool

The healthy value.
last_check datetime

The last check value.
metrics dict[str, Any] | None

The metrics value.
success_count int

The success count value.
Methods:
__contains__ 
__contains__(key: str) -> bool

Build internal contains.

Parameters:

Name Type Description Default
key str

The key value.

 required

Returns:

Name Type Description
bool bool

True if contains, otherwise False.
Source code in src/solidworks_mcp/adapters/base.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
def __contains__(self, key: str) -> bool:
    """Build internal contains.

    Args:
        key (str): The key value.

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

Build internal getitem.

Parameters:

Name Type Description Default
key str

The key value.

 required

Returns:

Name Type Description
Any Any

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
def __getitem__(self, key: str) -> Any:
    """Build internal getitem.

    Args:
        key (str): The key value.

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

AdapterResult dataclass 

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

Bases: Generic[T]

Result wrapper for adapter operations.

Attributes:

Name Type Description
data T | None

The data value.
error str | None

The error value.
execution_time float | None

The execution time value.
metadata dict[str, Any] | None

The metadata value.
status AdapterResultStatus

The status value.
Attributes
is_error property 
is_error: bool

Check if operation had an error.

Returns:

Name Type Description
bool bool

True if error, otherwise False.
is_success property 
is_success: bool

Check if operation was successful.

Returns:

Name Type Description
bool bool

True if success, otherwise False.

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.

CircuitBreakerAdapter 

CircuitBreakerAdapter(adapter: SolidWorksAdapter | None = None, failure_threshold: int = 5, recovery_timeout: int = 60, half_open_max_calls: int = 3, config: dict[str, object] | None = None)

Bases: SolidWorksAdapter

Circuit breaker wrapper for SolidWorks adapters.

Parameters:

Name Type Description Default
adapter SolidWorksAdapter | None

Adapter instance used for the operation. Defaults to None.

 None
failure_threshold int

The failure threshold value. Defaults to 5.

 5
recovery_timeout int

The recovery timeout value. Defaults to 60.

 60
half_open_max_calls int

The half open max calls value. Defaults to 3.

 3
config dict[str, object] | None

Configuration values for the operation. Defaults to None.

 None

Attributes:

Name Type Description
adapter Any

The adapter value.
failure_count Any

The failure count value.
failure_threshold Any

The failure threshold value.
half_open_calls Any

The half open calls value.
half_open_max_calls Any

The half open max calls value.
recovery_timeout Any

The recovery timeout value.
state Any

The state value.

Initialize the circuit breaker adapter.

Parameters:

Name Type Description Default
adapter SolidWorksAdapter | None

Adapter instance used for the operation. Defaults to None.

 None
failure_threshold int

The failure threshold value. Defaults to 5.

 5
recovery_timeout int

The recovery timeout value. Defaults to 60.

 60
half_open_max_calls int

The half open max calls value. Defaults to 3.

 3
config dict[str, 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/circuit_breaker.py 
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 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
def __init__(
    self,
    adapter: SolidWorksAdapter | None = None,
    failure_threshold: int = 5,
    recovery_timeout: int = 60,
    half_open_max_calls: int = 3,
    config: dict[str, object] | None = None,
) -> None:
    """Initialize the circuit breaker adapter.

    Args:
        adapter (SolidWorksAdapter | None): Adapter instance used for the operation.
                                            Defaults to None.
        failure_threshold (int): The failure threshold value. Defaults to 5.
        recovery_timeout (int): The recovery timeout value. Defaults to 60.
        half_open_max_calls (int): The half open max calls value. Defaults to 3.
        config (dict[str, object] | None): Configuration values for the operation. Defaults
                                           to None.

    Returns:
        None: None.
    """
    if adapter is None:
        from .mock_adapter import MockSolidWorksAdapter

        adapter = MockSolidWorksAdapter(config or {})
    super().__init__(config)
    self.adapter = adapter
    self.failure_threshold = failure_threshold
    self.recovery_timeout = recovery_timeout
    self.half_open_max_calls = half_open_max_calls

    self.state = CircuitState.CLOSED
    self.failure_count = 0
    self.last_failure_time: float = 0.0
    self.half_open_calls = 0
Methods:
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 arc through circuit breaker.

Parameters:

Name Type Description Default
center_x float

Arc center X coordinate.

 required
center_y float

Arc center Y coordinate.

 required
start_x float

Arc start X coordinate.

 required
start_y float

Arc start Y coordinate.

 required
end_x float

Arc end X coordinate.

 required
end_y float

Arc end Y coordinate.

 required

Returns:

Type Description
AdapterResult[str]

AdapterResult[str]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
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
719
720
721
722
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 arc through circuit breaker.

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

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "add_arc",
        lambda: self.adapter.add_arc(
            center_x,
            center_y,
            start_x,
            start_y,
            end_x,
            end_y,
        ),
        input_dict={
            "center_x": center_x,
            "center_y": center_y,
            "start_x": start_x,
            "start_y": start_y,
            "end_x": end_x,
            "end_y": end_y,
        },
    )
add_centerline async 
add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add centerline through circuit breaker.

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/circuit_breaker.py 
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add centerline through circuit breaker.

    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 await self._execute_with_circuit_breaker(
        "add_centerline",
        lambda: self.adapter.add_centerline(x1, y1, x2, y2),
        input_dict={"x1": x1, "y1": y1, "x2": x2, "y2": y2},
    )
add_circle async 
add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Add circle through circuit breaker.

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/circuit_breaker.py 
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Add circle through circuit breaker.

    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.
    """
    return await self._execute_with_circuit_breaker(
        "add_circle",
        lambda: self.adapter.add_circle(center_x, center_y, radius),
        input_dict={"center_x": center_x, "center_y": center_y, "radius": radius},
    )
add_ellipse async 
add_ellipse(center_x: float, center_y: float, major_axis: float, minor_axis: float) -> AdapterResult[str]

Add ellipse through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
async def add_ellipse(
    self,
    center_x: float,
    center_y: float,
    major_axis: float,
    minor_axis: float,
) -> AdapterResult[str]:
    """Add ellipse through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_ellipse",
        lambda: self.adapter.add_ellipse(
            center_x, center_y, major_axis, minor_axis
        ),
        input_dict={
            "center_x": center_x,
            "center_y": center_y,
            "major_axis": major_axis,
            "minor_axis": minor_axis,
        },
    )
add_fillet async 
add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[SolidWorksFeature]

Add fillet through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
525
526
527
528
529
530
531
532
533
async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[SolidWorksFeature]:
    """Add fillet through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_fillet",
        lambda: self.adapter.add_fillet(radius, edge_names),
        input_dict={"radius": radius, "edge_names": edge_names},
    )
add_line async 
add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add line through circuit breaker.

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/circuit_breaker.py 
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add line through circuit breaker.

    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 await self._execute_with_circuit_breaker(
        "add_line",
        lambda: self.adapter.add_line(x1, y1, x2, y2),
        input_dict={"x1": x1, "y1": y1, "x2": x2, "y2": y2},
    )
add_mate async 
add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0) -> AdapterResult[dict[str, Any]]

Add mate through circuit breaker.

Parameters:

Name Type Description Default
component_a str

First component instance name.

 required
component_b str

Second component instance name.

 required
entity_a str

Named feature on the first component. Defaults to "Front Plane".

 'Front Plane'
entity_b str

Named feature on the second component. Defaults to "Front Plane".

 'Front Plane'
mate_type str

Mate type. Defaults to "coincident".

 'coincident'
alignment str

Mate alignment. Defaults to "aligned".

 'aligned'
distance float

Distance in millimetres. Defaults to 0.0.

 0.0
angle float

Angle in degrees. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
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
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
) -> AdapterResult[dict[str, Any]]:
    """Add mate through circuit breaker.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type. Defaults to "coincident".
        alignment (str): Mate alignment. Defaults to "aligned".
        distance (float): Distance in millimetres. Defaults to 0.0.
        angle (float): Angle in degrees. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "add_mate",
        lambda: self.adapter.add_mate(
            component_a,
            component_b,
            entity_a,
            entity_b,
            mate_type,
            alignment,
            distance,
            angle,
        ),
        input_dict={
            "component_a": component_a,
            "component_b": component_b,
            "entity_a": entity_a,
            "entity_b": entity_b,
            "mate_type": mate_type,
            "alignment": alignment,
            "distance": distance,
            "angle": angle,
        },
    )
add_polygon async 
add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Add polygon through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
732
733
734
735
736
737
738
739
740
741
742
743
744
745
async def add_polygon(
    self, center_x: float, center_y: float, radius: float, sides: int
) -> AdapterResult[str]:
    """Add polygon through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_polygon",
        lambda: self.adapter.add_polygon(center_x, center_y, radius, sides),
        input_dict={
            "center_x": center_x,
            "center_y": center_y,
            "radius": radius,
            "sides": sides,
        },
    )
add_rectangle async 
add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add rectangle through circuit breaker.

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/circuit_breaker.py 
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add rectangle through circuit breaker.

    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 await self._execute_with_circuit_breaker(
        "add_rectangle",
        lambda: self.adapter.add_rectangle(x1, y1, x2, y2),
        input_dict={"x1": x1, "y1": y1, "x2": x2, "y2": y2},
    )
add_sketch_constraint async 
add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Add sketch constraint through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Add sketch constraint through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_sketch_constraint",
        lambda: self.adapter.add_sketch_constraint(
            entity1,
            entity2,
            relation_type,
            entity3,
        ),
        input_dict={
            "entity1": entity1,
            "entity2": entity2,
            "relation_type": relation_type,
            "entity3": entity3,
        },
    )
add_sketch_dimension async 
add_sketch_dimension(entity1: str, entity2: str | None, dimension_type: str, value: float) -> AdapterResult[str]

Add sketch dimension through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
async def add_sketch_dimension(
    self,
    entity1: str,
    entity2: str | None,
    dimension_type: str,
    value: float,
) -> AdapterResult[str]:
    """Add sketch dimension through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_sketch_dimension",
        lambda: self.adapter.add_sketch_dimension(
            entity1,
            entity2,
            dimension_type,
            value,
        ),
        input_dict={
            "entity1": entity1,
            "entity2": entity2,
            "dimension_type": dimension_type,
            "value": value,
        },
    )
add_spline async 
add_spline(points: list[dict[str, float]]) -> AdapterResult[str]

Add spline through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
724
725
726
727
728
729
730
async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
    """Add spline through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "add_spline",
        lambda: self.adapter.add_spline(points),
        input_dict={"points": points},
    )
call async 
call(operation: Callable[[], object | Awaitable[object]]) -> object

Legacy call API used by tests.

Parameters:

Name Type Description Default
operation Callable[[], object | Awaitable[object]]

Callable object executed by the helper.

 required

Returns:

Name Type Description
object object

The result produced by the operation.

Raises:

Type Description
RuntimeError

If the operation cannot be completed.
Exception

Circuit breaker is open.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
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
async def call(self, operation: Callable[[], object | Awaitable[object]]) -> object:
    """Legacy call API used by tests.

    Args:
        operation (Callable[[], object | Awaitable[object]]): Callable object executed by
                                                              the helper.

    Returns:
        object: The result produced by the operation.

    Raises:
        RuntimeError: If the operation cannot be completed.
        Exception: Circuit breaker is open.
    """
    if not self._should_allow_request():
        raise Exception("Circuit breaker is open")
    try:
        result = operation()
        if asyncio.iscoroutine(result):
            result = await result
        self._record_success()
        return result
    except Exception as exc:
        self._record_failure()
        raise RuntimeError(str(exc)) from exc
check_sketch_fully_defined async 
check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Check sketch definition status through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
881
882
883
884
885
886
887
888
889
async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Check sketch definition status through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "check_sketch_fully_defined",
        lambda: self.adapter.check_sketch_fully_defined(sketch_name),
        input_dict={"sketch_name": sketch_name},
    )
close_model async 
close_model(save: bool = False) -> AdapterResult[None]

Close model through circuit breaker.

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/circuit_breaker.py 
346
347
348
349
350
351
352
353
354
355
356
357
358
359
async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Close model through circuit breaker.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "close_model",
        lambda: self.adapter.close_model(save),
        input_dict={"save": save},
    )
connect async 
connect() -> None

Connect through circuit breaker.

Returns:

Name Type Description
None None

None.

Raises:

Type Description
Exception

If the operation cannot be completed.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
async def connect(self) -> None:
    """Connect through circuit breaker.

    Returns:
        None: None.

    Raises:
        Exception: If the operation cannot be completed.
    """
    if not self._should_allow_request():
        raise Exception(f"Circuit breaker is {self.state.value}")

    try:
        await self.adapter.connect()
        self._record_success()
    except Exception:
        self._record_failure()
        raise
create_assembly async 
create_assembly(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create assembly through circuit breaker.

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/circuit_breaker.py 
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
async def create_assembly(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create assembly through circuit breaker.

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

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

    async def _op() -> AdapterResult[SolidWorksModel]:
        """Build internal op.

        Returns:
            AdapterResult[SolidWorksModel]: The result produced by the operation.
        """
        if name is None:
            return await self.adapter.create_assembly()
        return await self._invoke_with_optional_args(
            self.adapter.create_assembly,
            name,
        )

    return await self._execute_with_circuit_breaker(
        "create_assembly", _op, input_dict={"name": name}
    )
create_cut_extrude async 
create_cut_extrude(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create cut-extrude through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
515
516
517
518
519
520
521
522
523
async def create_cut_extrude(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create cut-extrude through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "create_cut_extrude",
        lambda: self.adapter.create_cut_extrude(params),
        input_dict=_to_input_dict(params),
    )
create_drawing async 
create_drawing(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create drawing through circuit breaker.

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/circuit_breaker.py 
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
async def create_drawing(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create drawing through circuit breaker.

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

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_drawing",
        lambda: self.adapter.create_drawing(name),
        input_dict={"name": name},
    )
create_extrusion async 
create_extrusion(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create extrusion through circuit breaker.

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/circuit_breaker.py 
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
async def create_extrusion(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create extrusion through circuit breaker.

    Args:
        params (ExtrusionParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_extrusion",
        lambda: self.adapter.create_extrusion(params),
        input_dict=_to_input_dict(params),
    )
create_loft async 
create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Create loft through circuit breaker.

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/circuit_breaker.py 
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create loft through circuit breaker.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_loft",
        lambda: self.adapter.create_loft(params),
        input_dict=_to_input_dict(params),
    )
create_part async 
create_part(name: str | None = None, units: str | None = None) -> AdapterResult[SolidWorksModel]

Create part through circuit breaker.

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/circuit_breaker.py 
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
async def create_part(
    self, name: str | None = None, units: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create part through circuit breaker.

    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.
    """

    async def _op() -> AdapterResult[SolidWorksModel]:
        """Build internal op.

        Returns:
            AdapterResult[SolidWorksModel]: The result produced by the operation.
        """
        if name is None and units is None:
            return await self.adapter.create_part()
        return await self._invoke_with_optional_args(
            self.adapter.create_part,
            name,
            units,
        )

    return await self._execute_with_circuit_breaker(
        "create_part", _op, input_dict={"name": name, "units": units}
    )
create_revolve async 
create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Create revolve through circuit breaker.

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/circuit_breaker.py 
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create revolve through circuit breaker.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_revolve",
        lambda: self.adapter.create_revolve(params),
        input_dict=_to_input_dict(params),
    )
create_sketch async 
create_sketch(plane: str) -> AdapterResult[str]

Create sketch through circuit breaker.

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/circuit_breaker.py 
588
589
590
591
592
593
594
595
596
597
598
599
600
601
async def create_sketch(self, plane: str) -> AdapterResult[str]:
    """Create sketch through circuit breaker.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_sketch",
        lambda: self.adapter.create_sketch(plane),
        input_dict={"plane": plane},
    )
create_sweep async 
create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Create sweep through circuit breaker.

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/circuit_breaker.py 
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create sweep through circuit breaker.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "create_sweep",
        lambda: self.adapter.create_sweep(params),
        input_dict=_to_input_dict(params),
    )
disconnect async 
disconnect() -> None

Disconnect - always allowed.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
290
291
292
293
294
295
296
async def disconnect(self) -> None:
    """Disconnect - always allowed.

    Returns:
        None: None.
    """
    await self.adapter.disconnect()
execute_macro async 
execute_macro(params: dict[str, Any]) -> AdapterResult[dict[str, Any]]

Provide execute macro support for the circuit breaker adapter.

Parameters:

Name Type Description Default
params dict[str, Any]

The params 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/circuit_breaker.py 
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
async def execute_macro(
    self, params: dict[str, Any]
) -> AdapterResult[dict[str, Any]]:
    """Provide execute macro support for the circuit breaker adapter.

    Args:
        params (dict[str, Any]): The params value.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "execute_macro",
        lambda: self.adapter.execute_macro(params),  # type: ignore[attr-defined]
        input_dict=params,
    )
exit_sketch async 
exit_sketch() -> AdapterResult[None]

Exit sketch through circuit breaker.

Returns:

Type Description
AdapterResult[None]

AdapterResult[None]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
891
892
893
894
895
896
897
898
899
900
901
async def exit_sketch(self) -> AdapterResult[None]:
    """Exit sketch through circuit breaker.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "exit_sketch",
        lambda: self.adapter.exit_sketch(),
        input_dict={},
    )
export_file async 
export_file(file_path: str, format_type: str) -> AdapterResult[None]

Export file through circuit breaker.

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/circuit_breaker.py 
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Export file through circuit breaker.

    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.
    """
    return await self._execute_with_circuit_breaker(
        "export_file",
        lambda: self.adapter.export_file(file_path, format_type),
        input_dict={"file_path": file_path, "format_type": format_type},
    )
export_image async 
export_image(payload: dict) -> AdapterResult[dict]

Export viewport image through circuit breaker.

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/circuit_breaker.py 
964
965
966
967
968
969
970
971
972
973
974
975
976
977
async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Export viewport image through circuit breaker.

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "export_image",
        lambda: self.adapter.export_image(payload),
        input_dict=payload,
    )
get_dimension async 
get_dimension(name: str) -> AdapterResult[float]

Get dimension through circuit breaker.

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/circuit_breaker.py 
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
async def get_dimension(self, name: str) -> AdapterResult[float]:
    """Get dimension through circuit breaker.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[float]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "get_dimension",
        lambda: self.adapter.get_dimension(name),
        input_dict={"name": name},
    )
get_mass_properties async 
get_mass_properties() -> AdapterResult[MassProperties]

Get mass properties through circuit breaker.

Returns:

Type Description
AdapterResult[MassProperties]

AdapterResult[MassProperties]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
905
906
907
908
909
910
911
912
913
914
915
async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Get mass properties through circuit breaker.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "get_mass_properties",
        lambda: self.adapter.get_mass_properties(),
        input_dict={},
    )
get_model_info async 
get_model_info() -> AdapterResult[dict[str, object]]

Get active model metadata through circuit breaker.

Returns:

Type Description
AdapterResult[dict[str, object]]

AdapterResult[dict[str, object]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
917
918
919
920
921
922
923
924
925
926
927
async def get_model_info(self) -> AdapterResult[dict[str, object]]:
    """Get active model metadata through circuit breaker.

    Returns:
        AdapterResult[dict[str, object]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "get_model_info",
        lambda: self.adapter.get_model_info(),
        input_dict={},
    )
health_check async 
health_check() -> AdapterHealth

Get health check with circuit breaker status.

Returns:

Name Type Description
AdapterHealth AdapterHealth

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
async def health_check(self) -> AdapterHealth:
    """Get health check with circuit breaker status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    base_health = await self.adapter.health_check()
    if base_health.metrics is None:
        base_health.metrics = {}
    base_health.metrics["circuit_breaker"] = {
        "state": self.state.value,
        "failure_count": self.failure_count,
        "last_failure_time": self.last_failure_time,
        "half_open_calls": self.half_open_calls,
    }

    # Consider circuit as unhealthy if open
    if self.state == CircuitState.OPEN:
        base_health.healthy = False
        base_health.connection_status = "circuit_breaker_open"

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

Insert component through circuit breaker.

Parameters:

Name Type Description Default
file_path str

Path to the target file.

 required
x float

X position in millimetres. Defaults to 0.0.

 0.0
y float

Y position in millimetres. Defaults to 0.0.

 0.0
z float

Z position in millimetres. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Insert component through circuit breaker.

    Args:
        file_path (str): Path to the target file.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "insert_component",
        lambda: self.adapter.insert_component(file_path, x, y, z),
        input_dict={"file_path": file_path, "x": x, "y": y, "z": z},
    )
is_connected 
is_connected() -> bool

Check connection status.

Returns:

Name Type Description
bool bool

True if connected, otherwise False.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
298
299
300
301
302
303
304
def is_connected(self) -> bool:
    """Check connection status.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self.adapter.is_connected()
list_components async 
list_components() -> AdapterResult[list[str]]

List components through circuit breaker.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
async def list_components(self) -> AdapterResult[list[str]]:
    """List components through circuit breaker.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "list_components",
        lambda: self.adapter.list_components(),
        input_dict={},
    )
list_configurations async 
list_configurations() -> AdapterResult[list[str]]

List model configurations through circuit breaker.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
950
951
952
953
954
955
956
957
958
959
960
async def list_configurations(self) -> AdapterResult[list[str]]:
    """List model configurations through circuit breaker.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "list_configurations",
        lambda: self.adapter.list_configurations(),
        input_dict={},
    )
list_features async 
list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, object]]]

List model features through circuit breaker.

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False.

 False
max_assembly_depth int

Sub-assembly recursion depth. Defaults to 2.

 2

Returns:

Type Description
AdapterResult[list[dict[str, object]]]

AdapterResult[list[dict[str, object]]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, object]]]:
    """List model features through circuit breaker.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
        max_assembly_depth (int): Sub-assembly recursion depth. Defaults to 2.

    Returns:
        AdapterResult[list[dict[str, object]]]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "list_features",
        lambda: self.adapter.list_features(include_suppressed, max_assembly_depth),
        input_dict={
            "include_suppressed": include_suppressed,
            "max_assembly_depth": max_assembly_depth,
        },
    )
open_model async 
open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Open model through circuit breaker.

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/circuit_breaker.py 
331
332
333
334
335
336
337
338
339
340
341
342
343
344
async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Open model through circuit breaker.

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

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "open_model",
        lambda: self.adapter.open_model(file_path),
        input_dict={"file_path": file_path},
    )
save_file async 
save_file(file_path: str | None = None) -> AdapterResult[None]

Save model through circuit breaker.

Parameters:

Name Type Description Default
file_path str | None

Path to the target file. Defaults to None.

 None

Returns:

Type Description
AdapterResult[None]

AdapterResult[None]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
361
362
363
364
365
366
367
368
369
370
371
372
373
374
async def save_file(self, file_path: str | None = None) -> AdapterResult[None]:
    """Save model through circuit breaker.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "save_file",
        lambda: self.adapter.save_file(file_path),
        input_dict={"file_path": file_path},
    )
set_dimension async 
set_dimension(name: str, value: float) -> AdapterResult[None]

Set dimension through circuit breaker.

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/circuit_breaker.py 
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Set dimension through circuit breaker.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_circuit_breaker(
        "set_dimension",
        lambda: self.adapter.set_dimension(name, value),
        input_dict={"name": name, "value": value},
    )
sketch_circular_pattern async 
sketch_circular_pattern(entities: list[str], angle: float, count: int) -> AdapterResult[str]

Sketch circular pattern through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
791
792
793
794
795
796
797
798
799
800
801
802
async def sketch_circular_pattern(
    self,
    entities: list[str],
    angle: float,
    count: int,
) -> AdapterResult[str]:
    """Sketch circular pattern through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "sketch_circular_pattern",
        lambda: self.adapter.sketch_circular_pattern(entities, angle, count),
        input_dict={"entities": entities, "angle": angle, "count": count},
    )
sketch_linear_pattern async 
sketch_linear_pattern(entities: list[str], direction_x: float, direction_y: float, spacing: float, count: int) -> AdapterResult[str]

Sketch linear pattern through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
async def sketch_linear_pattern(
    self,
    entities: list[str],
    direction_x: float,
    direction_y: float,
    spacing: float,
    count: int,
) -> AdapterResult[str]:
    """Sketch linear pattern through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "sketch_linear_pattern",
        lambda: self.adapter.sketch_linear_pattern(
            entities, direction_x, direction_y, spacing, count
        ),
        input_dict={
            "entities": entities,
            "direction_x": direction_x,
            "direction_y": direction_y,
            "spacing": spacing,
            "count": count,
        },
    )
sketch_mirror async 
sketch_mirror(entities: list[str], mirror_line: str) -> AdapterResult[str]

Sketch mirror through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
804
805
806
807
808
809
810
811
812
async def sketch_mirror(
    self, entities: list[str], mirror_line: str
) -> AdapterResult[str]:
    """Sketch mirror through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "sketch_mirror",
        lambda: self.adapter.sketch_mirror(entities, mirror_line),
        input_dict={"entities": entities, "mirror_line": mirror_line},
    )
sketch_offset async 
sketch_offset(entities: list[str], offset_distance: float, reverse_direction: bool) -> AdapterResult[str]

Sketch offset through circuit breaker.

Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
async def sketch_offset(
    self,
    entities: list[str],
    offset_distance: float,
    reverse_direction: bool,
) -> AdapterResult[str]:
    """Sketch offset through circuit breaker."""
    return await self._execute_with_circuit_breaker(
        "sketch_offset",
        lambda: self.adapter.sketch_offset(
            entities, offset_distance, reverse_direction
        ),
        input_dict={
            "entities": entities,
            "offset_distance": offset_distance,
            "reverse_direction": reverse_direction,
        },
    )
soc_create_checkpoint async 
soc_create_checkpoint(label: str, file_path: str, *, feature_tree: list[dict[str, Any]] | None = None) -> int | None

Create a named SoC checkpoint after saving the model.

Records a SoCCheckpoint row and a ModelStateSnapshot. Call this immediately after save_file to mark a stable rollback point.

Parameters:

Name Type Description Default
label str

Short human name (e.g. "base-extrude").

 required
file_path str

Path of the .sldprt that was just saved.

 required
feature_tree list | None

Optional feature list from list_features().

 None

Returns:

Type Description
int | None

int | None: The new SoCCheckpoint.id, or None if soc_session_id is unset.
Source code in src/solidworks_mcp/adapters/circuit_breaker.py 
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
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
async def soc_create_checkpoint(
    self,
    label: str,
    file_path: str,
    *,
    feature_tree: list[dict[str, Any]] | None = None,
) -> int | None:
    """Create a named SoC checkpoint after saving the model.

    Records a SoCCheckpoint row and a ModelStateSnapshot.  Call this
    immediately after ``save_file`` to mark a stable rollback point.

    Args:
        label (str): Short human name (e.g. "base-extrude").
        file_path (str): Path of the .sldprt that was just saved.
        feature_tree (list | None): Optional feature list from list_features().

    Returns:
        int | None: The new SoCCheckpoint.id, or None if soc_session_id is unset.
    """
    if not self.soc_session_id:
        return None
    try:
        from solidworks_mcp.agents.history_db import (
            create_soc_checkpoint,
            insert_model_state_snapshot,
            list_tool_call_records,
        )

        records = list_tool_call_records(
            self.soc_session_id, db_path=self.soc_db_path
        )
        last_id = records[-1]["id"] if records else None

        snapshot_id: int | None = None
        if feature_tree is not None:
            import json as _json

            insert_model_state_snapshot(
                session_id=self.soc_session_id,
                model_path=file_path,
                feature_tree_json=_json.dumps(feature_tree, default=str),
                db_path=self.soc_db_path,
            )
            from solidworks_mcp.agents.history_db import list_model_state_snapshots

            snaps = list_model_state_snapshots(
                self.soc_session_id, db_path=self.soc_db_path
            )
            if snaps:
                snapshot_id = snaps[0]["id"]

        return create_soc_checkpoint(
            session_id=self.soc_session_id,
            label=label,
            file_path=file_path,
            last_record_id=last_id,
            snapshot_id=snapshot_id,
            db_path=self.soc_db_path,
        )
    except Exception as exc:
        logger.debug(
            f"[soc_checkpoint] failed to create checkpoint {label!r}: {exc}"
        )
        return None

ComplexityAnalyzer 

ComplexityAnalyzer(parameter_threshold: int = 12, score_threshold: float = 0.6)

Analyze operation complexity and recommend COM or VBA execution path.

Parameters:

Name Type Description Default
parameter_threshold int

The parameter threshold value. Defaults to 12.

 12
score_threshold float

The score threshold value. Defaults to 0.6.

 0.6

Attributes:

Name Type Description
_parameter_threshold Any

The parameter threshold value.
_score_threshold Any

The score threshold value.

Initialize analyzer state.

Parameters:

Name Type Description Default
parameter_threshold int

The parameter threshold value. Defaults to 12.

 12
score_threshold float

The score threshold value. Defaults to 0.6.

 0.6

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/complexity_analyzer.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
def __init__(
    self,
    parameter_threshold: int = 12,
    score_threshold: float = 0.6,
) -> None:
    """Initialize analyzer state.

    Args:
        parameter_threshold (int): The parameter threshold value. Defaults to 12.
        score_threshold (float): The score threshold value. Defaults to 0.6.

    Returns:
        None: None.
    """
    self._parameter_threshold = max(parameter_threshold, 1)
    self._score_threshold = max(min(score_threshold, 1.0), 0.1)
    self._profiles: dict[str, OperationProfile] = self._default_profiles()
    self._history: dict[str, dict[str, int]] = {}
Methods:
analyze 
analyze(operation: str, payload: object) -> RoutingDecision

Produce a routing recommendation for an operation call.

Parameters:

Name Type Description Default
operation str

Callable object executed by the helper.

 required
payload object

The payload value.

 required

Returns:

Name Type Description
RoutingDecision RoutingDecision

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/complexity_analyzer.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 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
120
121
122
123
124
def analyze(self, operation: str, payload: object) -> RoutingDecision:
    """Produce a routing recommendation for an operation call.

    Args:
        operation (str): Callable object executed by the helper.
        payload (object): The payload value.

    Returns:
        RoutingDecision: The result produced by the operation.
    """
    profile = self._profiles.get(
        operation,
        OperationProfile(name=operation, base_complexity=0.2, vba_preferred=False),
    )
    parameter_count = self._count_parameters(payload)

    parameter_component = min(
        parameter_count / float(self._parameter_threshold), 1.0
    )
    history_component = self._history_bias(operation)
    complexity_score = min(
        1.0,
        (parameter_component * 0.45)
        + (profile.base_complexity * 0.40)
        + (history_component * 0.15),
    )

    prefer_vba = (
        parameter_count > self._parameter_threshold
        or profile.vba_preferred
        or complexity_score >= self._score_threshold
    )

    reason = (
        "parameter threshold exceeded"
        if parameter_count > self._parameter_threshold
        else "profile prefers VBA"
        if profile.vba_preferred
        else "complexity score exceeded threshold"
        if complexity_score >= self._score_threshold
        else "COM path preferred"
    )

    return RoutingDecision(
        operation=operation,
        parameter_count=parameter_count,
        complexity_score=complexity_score,
        prefer_vba=prefer_vba,
        reason=reason,
    )
record_result 
record_result(operation: str, route: str, success: bool) -> None

Record operation outcome for future routing influence.

Parameters:

Name Type Description Default
operation str

Callable object executed by the helper.

 required
route str

The route value.

 required
success bool

The success value.

 required

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/complexity_analyzer.py 
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
def record_result(self, operation: str, route: str, success: bool) -> None:
    """Record operation outcome for future routing influence.

    Args:
        operation (str): Callable object executed by the helper.
        route (str): The route value.
        success (bool): The success value.

    Returns:
        None: None.
    """
    history = self._history.setdefault(
        operation,
        {
            "com_success": 0,
            "com_failure": 0,
            "vba_success": 0,
            "vba_failure": 0,
        },
    )
    key = f"{route}_{'success' if success else 'failure'}"
    if key in history:
        history[key] += 1

ConnectionPoolAdapter 

ConnectionPoolAdapter(adapter_factory: Callable[[], SolidWorksAdapter] | None = None, pool_size: int = 3, max_retries: int = 3, create_connection: Callable[[], SolidWorksAdapter] | None = None, max_size: int | None = None, timeout: float | None = None, config: dict[str, object] | None = None)

Bases: SolidWorksAdapter

Connection pool wrapper for SolidWorks adapters.

Parameters:

Name Type Description Default
adapter_factory Callable[[], SolidWorksAdapter] | None

Factory callable used to create adapter instances. Defaults to None.

 None
pool_size int

Number of adapters to maintain in the pool. Defaults to 3.

 3
max_retries int

Maximum number of retry attempts. Defaults to 3.

 3
create_connection Callable[[], SolidWorksAdapter] | None

Factory callable used to create a connection. Defaults to None.

 None
max_size int | None

Maximum number of items allowed in the pool. Defaults to None.

 None
timeout float | None

Maximum time to wait in seconds. Defaults to None.

 None
config dict[str, object] | None

Configuration values for the operation. Defaults to None.

 None

Attributes:

Name Type Description
_lock Any

The lock value.
adapter_factory Any

The adapter factory value.
max_retries Any

The max retries value.
pool_initialized Any

The pool initialized value.
pool_size Any

The pool size value.
timeout Any

The timeout value.

Initialize the connection pool adapter.

Parameters:

Name Type Description Default
adapter_factory Callable[[], SolidWorksAdapter] | None

Factory callable used to create adapter instances. Defaults to None.

 None
pool_size int

Number of adapters to maintain in the pool. Defaults to 3.

 3
max_retries int

Maximum number of retry attempts. Defaults to 3.

 3
create_connection Callable[[], SolidWorksAdapter] | None

Factory callable used to create a connection. Defaults to None.

 None
max_size int | None

Maximum number of items allowed in the pool. Defaults to None.

 None
timeout float | None

Maximum time to wait in seconds. Defaults to None.

 None
config dict[str, 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/connection_pool.py 
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 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
def __init__(
    self,
    adapter_factory: Callable[[], SolidWorksAdapter] | None = None,
    pool_size: int = 3,
    max_retries: int = 3,
    create_connection: Callable[[], SolidWorksAdapter] | None = None,
    max_size: int | None = None,
    timeout: float | None = None,
    config: dict[str, object] | None = None,
) -> None:
    """Initialize the connection pool adapter.

    Args:
        adapter_factory (Callable[[], SolidWorksAdapter] | None): Factory callable used to
                                                                  create adapter instances.
                                                                  Defaults to None.
        pool_size (int): Number of adapters to maintain in the pool. Defaults to 3.
        max_retries (int): Maximum number of retry attempts. Defaults to 3.
        create_connection (Callable[[], SolidWorksAdapter] | None): Factory callable used to
                                                                    create a connection.
                                                                    Defaults to None.
        max_size (int | None): Maximum number of items allowed in the pool. Defaults to
                               None.
        timeout (float | None): Maximum time to wait in seconds. Defaults to None.
        config (dict[str, object] | None): Configuration values for the operation. Defaults
                                           to None.

    Returns:
        None: None.
    """
    if adapter_factory is None and create_connection is not None:
        adapter_factory = create_connection
    if max_size is not None:
        pool_size = max_size
    if adapter_factory is None:
        from .mock_adapter import MockSolidWorksAdapter

        def adapter_factory() -> MockSolidWorksAdapter:
            """Provide adapter factory support for the connection pool adapter.

            Returns:
                MockSolidWorksAdapter: The result produced by the operation.
            """

            return MockSolidWorksAdapter(config or {})

    super().__init__(config)
    self.adapter_factory = adapter_factory
    self.pool_size = pool_size
    self.max_retries = max_retries

    self.pool: list[SolidWorksAdapter] = []
    self.available_adapters: asyncio.Queue[SolidWorksAdapter] = asyncio.Queue()
    self.pool_initialized = False
    self._lock = asyncio.Lock()
    self.timeout = timeout if timeout is not None else 30.0
Attributes
active_connections property 
active_connections: int

Provide active connections support for the connection pool adapter.

Returns:

Name Type Description
int int

The computed numeric result.
size property 
size: int

Provide size support for the connection pool adapter.

Returns:

Name Type Description
int int

The computed numeric result.
Methods:
acquire async 
acquire() -> SolidWorksAdapter

Provide acquire support for the connection pool adapter.

Returns:

Name Type Description
SolidWorksAdapter SolidWorksAdapter

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
224
225
226
227
228
229
230
async def acquire(self) -> SolidWorksAdapter:
    """Provide acquire support for the connection pool adapter.

    Returns:
        SolidWorksAdapter: The result produced by the operation.
    """
    return await self._get_adapter(timeout=self.timeout)
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 arc using pool.

Parameters:

Name Type Description Default
center_x float

Arc center X coordinate.

 required
center_y float

Arc center Y coordinate.

 required
start_x float

Arc start X coordinate.

 required
start_y float

Arc start Y coordinate.

 required
end_x float

Arc end X coordinate.

 required
end_y float

Arc end Y coordinate.

 required

Returns:

Type Description
AdapterResult[str]

AdapterResult[str]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
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
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 arc using pool.

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

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "add_arc",
        lambda adapter: adapter.add_arc(
            center_x,
            center_y,
            start_x,
            start_y,
            end_x,
            end_y,
        ),
    )
add_centerline async 
add_centerline(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add centerline using pool.

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/connection_pool.py 
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
async def add_centerline(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add centerline using pool.

    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 await self._execute_with_pool(
        "add_centerline",
        lambda adapter: adapter.add_centerline(x1, y1, x2, y2),
    )
add_circle async 
add_circle(center_x: float, center_y: float, radius: float) -> AdapterResult[str]

Add circle using pool.

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/connection_pool.py 
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
async def add_circle(
    self, center_x: float, center_y: float, radius: float
) -> AdapterResult[str]:
    """Add circle using pool.

    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.
    """
    return await self._execute_with_pool(
        "add_circle", lambda adapter: adapter.add_circle(center_x, center_y, radius)
    )
add_fillet async 
add_fillet(radius: float, edge_names: list[str]) -> AdapterResult[SolidWorksFeature]

Add fillet using pool.

Source code in src/solidworks_mcp/adapters/connection_pool.py 
614
615
616
617
618
619
620
async def add_fillet(
    self, radius: float, edge_names: list[str]
) -> AdapterResult[SolidWorksFeature]:
    """Add fillet using pool."""
    return await self._execute_with_pool(
        "add_fillet", lambda adapter: adapter.add_fillet(radius, edge_names)
    )
add_line async 
add_line(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add line using pool.

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/connection_pool.py 
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add line using pool.

    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 await self._execute_with_pool(
        "add_line", lambda adapter: adapter.add_line(x1, y1, x2, y2)
    )
add_mate async 
add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0) -> AdapterResult[dict[str, Any]]

Add mate using pool.

Parameters:

Name Type Description Default
component_a str

First component instance name.

 required
component_b str

Second component instance name.

 required
entity_a str

Named feature on the first component. Defaults to "Front Plane".

 'Front Plane'
entity_b str

Named feature on the second component. Defaults to "Front Plane".

 'Front Plane'
mate_type str

Mate type. Defaults to "coincident".

 'coincident'
alignment str

Mate alignment. Defaults to "aligned".

 'aligned'
distance float

Distance in millimetres. Defaults to 0.0.

 0.0
angle float

Angle in degrees. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
) -> AdapterResult[dict[str, Any]]:
    """Add mate using pool.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type. Defaults to "coincident".
        alignment (str): Mate alignment. Defaults to "aligned".
        distance (float): Distance in millimetres. Defaults to 0.0.
        angle (float): Angle in degrees. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "add_mate",
        lambda adapter: adapter.add_mate(
            component_a,
            component_b,
            entity_a,
            entity_b,
            mate_type,
            alignment,
            distance,
            angle,
        ),
    )
add_rectangle async 
add_rectangle(x1: float, y1: float, x2: float, y2: float) -> AdapterResult[str]

Add rectangle using pool.

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/connection_pool.py 
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
async def add_rectangle(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add rectangle using pool.

    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 await self._execute_with_pool(
        "add_rectangle", lambda adapter: adapter.add_rectangle(x1, y1, x2, y2)
    )
add_sketch_constraint async 
add_sketch_constraint(entity1: str, entity2: str | None, relation_type: str, entity3: str | None = None) -> AdapterResult[str]

Add sketch constraint using pool.

Source code in src/solidworks_mcp/adapters/connection_pool.py 
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
async def add_sketch_constraint(
    self,
    entity1: str,
    entity2: str | None,
    relation_type: str,
    entity3: str | None = None,
) -> AdapterResult[str]:
    """Add sketch constraint using pool."""
    return await self._execute_with_pool(
        "add_sketch_constraint",
        lambda adapter: adapter.add_sketch_constraint(
            entity1,
            entity2,
            relation_type,
            entity3,
        ),
    )
add_sketch_dimension async 
add_sketch_dimension(entity1: str, entity2: str | None, dimension_type: str, value: float) -> AdapterResult[str]

Add sketch dimension using pool.

Source code in src/solidworks_mcp/adapters/connection_pool.py 
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
async def add_sketch_dimension(
    self,
    entity1: str,
    entity2: str | None,
    dimension_type: str,
    value: float,
) -> AdapterResult[str]:
    """Add sketch dimension using pool."""
    return await self._execute_with_pool(
        "add_sketch_dimension",
        lambda adapter: adapter.add_sketch_dimension(
            entity1,
            entity2,
            dimension_type,
            value,
        ),
    )
check_sketch_fully_defined async 
check_sketch_fully_defined(sketch_name: str | None = None) -> AdapterResult[dict[str, Any]]

Check sketch definition status using pool.

Source code in src/solidworks_mcp/adapters/connection_pool.py 
824
825
826
827
828
829
830
831
async def check_sketch_fully_defined(
    self, sketch_name: str | None = None
) -> AdapterResult[dict[str, Any]]:
    """Check sketch definition status using pool."""
    return await self._execute_with_pool(
        "check_sketch_fully_defined",
        lambda adapter: adapter.check_sketch_fully_defined(sketch_name),
    )
cleanup async 
cleanup() -> None

Provide cleanup support for the connection pool adapter.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
243
244
245
246
247
248
249
async def cleanup(self) -> None:
    """Provide cleanup support for the connection pool adapter.

    Returns:
        None: None.
    """
    await self.disconnect()
close_model async 
close_model(save: bool = False) -> AdapterResult[None]

Close model using pool.

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/connection_pool.py 
487
488
489
490
491
492
493
494
495
496
497
498
async def close_model(self, save: bool = False) -> AdapterResult[None]:
    """Close model using pool.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "close_model", lambda adapter: adapter.close_model(save)
    )
connect async 
connect() -> None

Initialize the connection pool.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
377
378
379
380
381
382
383
async def connect(self) -> None:
    """Initialize the connection pool.

    Returns:
        None: None.
    """
    await self._initialize_pool()
create_assembly async 
create_assembly(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create assembly using pool.

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/connection_pool.py 
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
async def create_assembly(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create assembly using pool.

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

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

    async def _op(adapter: SolidWorksAdapter) -> AdapterResult[SolidWorksModel]:
        """Build internal op.

        Args:
            adapter (SolidWorksAdapter): Adapter instance used for the operation.

        Returns:
            AdapterResult[SolidWorksModel]: The result produced by the operation.
        """
        if name is None:
            return await adapter.create_assembly()
        result = await self._invoke_with_optional_args(
            adapter, "create_assembly", name
        )
        return cast(AdapterResult[SolidWorksModel], result)

    return await self._execute_with_pool("create_assembly", _op)
create_cut_extrude async 
create_cut_extrude(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create cut-extrude using pool.

Source code in src/solidworks_mcp/adapters/connection_pool.py 
606
607
608
609
610
611
612
async def create_cut_extrude(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create cut-extrude using pool."""
    return await self._execute_with_pool(
        "create_cut_extrude", lambda adapter: adapter.create_cut_extrude(params)
    )
create_drawing async 
create_drawing(name: str | None = None) -> AdapterResult[SolidWorksModel]

Create drawing using pool.

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/connection_pool.py 
574
575
576
577
578
579
580
581
582
583
584
585
586
587
async def create_drawing(
    self, name: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create drawing using pool.

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

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_drawing", lambda adapter: adapter.create_drawing(name)
    )
create_extrusion async 
create_extrusion(params: ExtrusionParameters) -> AdapterResult[SolidWorksFeature]

Create extrusion using pool.

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/connection_pool.py 
591
592
593
594
595
596
597
598
599
600
601
602
603
604
async def create_extrusion(
    self, params: ExtrusionParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create extrusion using pool.

    Args:
        params (ExtrusionParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_extrusion", lambda adapter: adapter.create_extrusion(params)
    )
create_loft async 
create_loft(params: LoftParameters) -> AdapterResult[SolidWorksFeature]

Create loft using pool.

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/connection_pool.py 
652
653
654
655
656
657
658
659
660
661
662
663
664
665
async def create_loft(
    self, params: LoftParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create loft using pool.

    Args:
        params (LoftParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_loft", lambda adapter: adapter.create_loft(params)
    )
create_part async 
create_part(name: str | None = None, units: str | None = None) -> AdapterResult[SolidWorksModel]

Create part using pool.

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/connection_pool.py 
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
540
541
542
async def create_part(
    self, name: str | None = None, units: str | None = None
) -> AdapterResult[SolidWorksModel]:
    """Create part using pool.

    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.
    """

    async def _op(adapter: SolidWorksAdapter) -> AdapterResult[SolidWorksModel]:
        """Build internal op.

        Args:
            adapter (SolidWorksAdapter): Adapter instance used for the operation.

        Returns:
            AdapterResult[SolidWorksModel]: The result produced by the operation.
        """
        if name is None and units is None:
            return await adapter.create_part()
        result = await self._invoke_with_optional_args(
            adapter, "create_part", name, units
        )
        return cast(AdapterResult[SolidWorksModel], result)

    return await self._execute_with_pool("create_part", _op)
create_revolve async 
create_revolve(params: RevolveParameters) -> AdapterResult[SolidWorksFeature]

Create revolve using pool.

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/connection_pool.py 
622
623
624
625
626
627
628
629
630
631
632
633
634
635
async def create_revolve(
    self, params: RevolveParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create revolve using pool.

    Args:
        params (RevolveParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_revolve", lambda adapter: adapter.create_revolve(params)
    )
create_sketch async 
create_sketch(plane: str) -> AdapterResult[str]

Create sketch using pool.

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/connection_pool.py 
669
670
671
672
673
674
675
676
677
678
679
680
async def create_sketch(self, plane: str) -> AdapterResult[str]:
    """Create sketch using pool.

    Args:
        plane (str): The plane value.

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_sketch", lambda adapter: adapter.create_sketch(plane)
    )
create_sweep async 
create_sweep(params: SweepParameters) -> AdapterResult[SolidWorksFeature]

Create sweep using pool.

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/connection_pool.py 
637
638
639
640
641
642
643
644
645
646
647
648
649
650
async def create_sweep(
    self, params: SweepParameters
) -> AdapterResult[SolidWorksFeature]:
    """Create sweep using pool.

    Args:
        params (SweepParameters): The params value.

    Returns:
        AdapterResult[SolidWorksFeature]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "create_sweep", lambda adapter: adapter.create_sweep(params)
    )
disconnect async 
disconnect() -> None

Disconnect all adapters in the pool.

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
async def disconnect(self) -> None:
    """Disconnect all adapters in the pool.

    Returns:
        None: None.
    """
    for adapter in self.pool:
        from .base import SolidWorksAdapter

        typed_adapter: SolidWorksAdapter = adapter
        _, error = await self._attempt_async_with_error(
            lambda a=typed_adapter: a.disconnect()  # type: ignore[misc]
        )
        if error is not None:
            logger.warning(f"Error disconnecting adapter: {error}")

    self.pool.clear()

    # Clear the queue
    while not self.available_adapters.empty():
        try:
            self.available_adapters.get_nowait()
        except asyncio.QueueEmpty:
            break

    self.pool_initialized = False
execute_macro async 
execute_macro(params: dict[str, Any]) -> AdapterResult[dict[str, Any]]

Provide execute macro support for the connection pool adapter.

Parameters:

Name Type Description Default
params dict[str, Any]

The params 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/connection_pool.py 
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
async def execute_macro(
    self, params: dict[str, Any]
) -> AdapterResult[dict[str, Any]]:
    """Provide execute macro support for the connection pool adapter.

    Args:
        params (dict[str, Any]): The params value.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "execute_macro",
        lambda adapter: adapter.execute_macro(params),  # type: ignore[attr-defined]
    )
exit_sketch async 
exit_sketch() -> AdapterResult[None]

Exit sketch using pool.

Returns:

Type Description
AdapterResult[None]

AdapterResult[None]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
833
834
835
836
837
838
839
840
841
async def exit_sketch(self) -> AdapterResult[None]:
    """Exit sketch using pool.

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "exit_sketch", lambda adapter: adapter.exit_sketch()
    )
export_file async 
export_file(file_path: str, format_type: str) -> AdapterResult[None]

Export file using pool.

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/connection_pool.py 
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
async def export_file(
    self, file_path: str, format_type: str
) -> AdapterResult[None]:
    """Export file using pool.

    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.
    """
    return await self._execute_with_pool(
        "export_file", lambda adapter: adapter.export_file(file_path, format_type)
    )
export_image async 
export_image(payload: dict) -> AdapterResult[dict]

Export viewport image using pool.

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/connection_pool.py 
912
913
914
915
916
917
918
919
920
921
922
923
async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Export viewport image using pool.

    Args:
        payload (dict): The payload value.

    Returns:
        AdapterResult[dict]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "export_image", lambda adapter: adapter.export_image(payload)
    )
get_dimension async 
get_dimension(name: str) -> AdapterResult[float]

Get dimension using pool.

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/connection_pool.py 
943
944
945
946
947
948
949
950
951
952
953
954
async def get_dimension(self, name: str) -> AdapterResult[float]:
    """Get dimension using pool.

    Args:
        name (str): The name value.

    Returns:
        AdapterResult[float]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "get_dimension", lambda adapter: adapter.get_dimension(name)
    )
get_mass_properties async 
get_mass_properties() -> AdapterResult[MassProperties]

Get mass properties using pool.

Returns:

Type Description
AdapterResult[MassProperties]

AdapterResult[MassProperties]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
845
846
847
848
849
850
851
852
853
async def get_mass_properties(self) -> AdapterResult[MassProperties]:
    """Get mass properties using pool.

    Returns:
        AdapterResult[MassProperties]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "get_mass_properties", lambda adapter: adapter.get_mass_properties()
    )
get_model_info async 
get_model_info() -> AdapterResult[dict[str, object]]

Get active model metadata using pool.

Returns:

Type Description
AdapterResult[dict[str, object]]

AdapterResult[dict[str, object]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
855
856
857
858
859
860
861
862
863
async def get_model_info(self) -> AdapterResult[dict[str, object]]:
    """Get active model metadata using pool.

    Returns:
        AdapterResult[dict[str, object]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "get_model_info", lambda adapter: adapter.get_model_info()
    )
health_check async 
health_check() -> AdapterHealth

Get health status of the connection pool.

Returns:

Name Type Description
AdapterHealth AdapterHealth

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
420
421
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
464
465
466
467
468
469
470
async def health_check(self) -> AdapterHealth:
    """Get health status of the connection pool.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    healthy_count = 0
    total_response_time = 0

    if not self.pool_initialized:
        return AdapterHealth(
            healthy=False,
            last_check=datetime.now(),
            error_count=0,
            success_count=0,
            average_response_time=0,
            connection_status="pool_not_initialized",
            metrics={
                "pool_size": 0,
                "available_adapters": 0,
                "healthy_adapters": 0,
            },
        )

    # Check health of all adapters
    for adapter in self.pool:
        from .base import SolidWorksAdapter

        typed_adapter: SolidWorksAdapter = adapter
        health = await self._attempt_async(lambda a=typed_adapter: a.health_check())  # type: ignore[misc]
        if not health:
            continue
        if health.healthy:
            healthy_count += 1
        total_response_time += health.average_response_time

    avg_response_time = total_response_time / len(self.pool) if self.pool else 0

    return AdapterHealth(
        healthy=healthy_count > 0,
        last_check=datetime.now(),
        error_count=len(self.pool) - healthy_count,
        success_count=healthy_count,
        average_response_time=avg_response_time,
        connection_status="pooled",
        metrics={
            "pool_size": len(self.pool),
            "available_adapters": self.available_adapters.qsize(),
            "healthy_adapters": healthy_count,
        },
    )
insert_component async 
insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Insert component using pool.

Parameters:

Name Type Description Default
file_path str

Path to the target file.

 required
x float

X position in millimetres. Defaults to 0.0.

 0.0
y float

Y position in millimetres. Defaults to 0.0.

 0.0
z float

Z position in millimetres. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Insert component using pool.

    Args:
        file_path (str): Path to the target file.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "insert_component",
        lambda adapter: adapter.insert_component(file_path, x, y, z),
    )
is_connected 
is_connected() -> bool

Check if pool is initialized.

Returns:

Name Type Description
bool bool

True if connected, otherwise False.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
412
413
414
415
416
417
418
def is_connected(self) -> bool:
    """Check if pool is initialized.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self.pool_initialized and len(self.pool) > 0
list_components async 
list_components() -> AdapterResult[list[str]]

List components using pool.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
991
992
993
994
995
996
997
998
999
async def list_components(self) -> AdapterResult[list[str]]:
    """List components using pool.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "list_components", lambda adapter: adapter.list_components()
    )
list_configurations async 
list_configurations() -> AdapterResult[list[str]]

List model configurations using pool.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
884
885
886
887
888
889
890
891
892
async def list_configurations(self) -> AdapterResult[list[str]]:
    """List model configurations using pool.

    Returns:
        AdapterResult[list[str]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "list_configurations", lambda adapter: adapter.list_configurations()
    )
list_features async 
list_features(include_suppressed: bool = False, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, object]]]

List model features using pool.

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False.

 False
max_assembly_depth int

Sub-assembly recursion depth. Defaults to 2.

 2

Returns:

Type Description
AdapterResult[list[dict[str, object]]]

AdapterResult[list[dict[str, object]]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, object]]]:
    """List model features using pool.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
        max_assembly_depth (int): Sub-assembly recursion depth. Defaults to 2.

    Returns:
        AdapterResult[list[dict[str, object]]]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "list_features",
        lambda adapter: adapter.list_features(
            include_suppressed, max_assembly_depth
        ),
    )
open_model async 
open_model(file_path: str) -> AdapterResult[SolidWorksModel]

Open model using pool.

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/connection_pool.py 
474
475
476
477
478
479
480
481
482
483
484
485
async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Open model using pool.

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

    Returns:
        AdapterResult[SolidWorksModel]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "open_model", lambda adapter: adapter.open_model(file_path)
    )
release async 
release(adapter: SolidWorksAdapter) -> None

Provide release support for the connection pool adapter.

Parameters:

Name Type Description Default
adapter SolidWorksAdapter

Adapter instance used for the operation.

 required

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
232
233
234
235
236
237
238
239
240
241
async def release(self, adapter: SolidWorksAdapter) -> None:
    """Provide release support for the connection pool adapter.

    Args:
        adapter (SolidWorksAdapter): Adapter instance used for the operation.

    Returns:
        None: None.
    """
    await self._return_adapter(adapter)
save_file async 
save_file(file_path: str | None = None) -> AdapterResult[None]

Save model using pool.

Parameters:

Name Type Description Default
file_path str | None

Path to the target file. Defaults to None.

 None

Returns:

Type Description
AdapterResult[None]

AdapterResult[None]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/connection_pool.py 
500
501
502
503
504
505
506
507
508
509
510
511
async def save_file(self, file_path: str | None = None) -> AdapterResult[None]:
    """Save model using pool.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "save_file", lambda adapter: adapter.save_file(file_path)
    )
set_dimension async 
set_dimension(name: str, value: float) -> AdapterResult[None]

Set dimension using pool.

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/connection_pool.py 
956
957
958
959
960
961
962
963
964
965
966
967
968
async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
    """Set dimension using pool.

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

    Returns:
        AdapterResult[None]: The result produced by the operation.
    """
    return await self._execute_with_pool(
        "set_dimension", lambda adapter: adapter.set_dimension(name, value)
    )

IntelligentRouter 

IntelligentRouter(analyzer: ComplexityAnalyzer, cache: ResponseCache, cacheable_operations: set[str] | None = None)

Route operations between COM and VBA paths using complexity analysis.

Parameters:

Name Type Description Default
analyzer ComplexityAnalyzer

The analyzer value.

 required
cache ResponseCache

The cache value.

 required
cacheable_operations set[str] | None

The cacheable operations value. Defaults to None.

 None

Attributes:

Name Type Description
_analyzer Any

The analyzer value.
_cache Any

The cache value.
_cacheable_operations Any

The cacheable operations value.

Initialize router dependencies.

Parameters:

Name Type Description Default
analyzer ComplexityAnalyzer

The analyzer value.

 required
cache ResponseCache

The cache value.

 required
cacheable_operations set[str] | None

The cacheable operations value. Defaults to None.

 None

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/intelligent_router.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def __init__(
    self,
    analyzer: ComplexityAnalyzer,
    cache: ResponseCache,
    cacheable_operations: set[str] | None = None,
) -> None:
    """Initialize router dependencies.

    Args:
        analyzer (ComplexityAnalyzer): The analyzer value.
        cache (ResponseCache): The cache value.
        cacheable_operations (set[str] | None): The cacheable operations value. Defaults to
                                                None.

    Returns:
        None: None.
    """
    self._analyzer = analyzer
    self._cache = cache
    self._cacheable_operations = cacheable_operations or {
        # Live document metadata is deliberately NOT cached. Model state,
        # save state, paths, features, configurations, dimensions and
        # properties can all change after any CAD operation, and this
        # router has no reliable mutation-triggered invalidation.
        # "get_model_info",
        # "list_features",
        # "list_configurations",
        # "get_file_properties",
        # "get_dimension",
        # Analysis operations — NOT cached: model state changes with
        # every feature-creation tool call and the router has no
        # automatic invalidation. Caching these produced stale
        # volumes mid-build.
        # "get_mass_properties",
        # "calculate_mass_properties",
        "get_material_properties",
        "analyze_geometry",
        "check_interference",
        # Drawing analysis operations
        "analyze_drawing_comprehensive",
        "analyze_drawing_dimensions",
        "analyze_drawing_views",
        "analyze_drawing_annotations",
        "check_drawing_compliance",
        "check_drawing_standards",
        "compare_drawing_versions",
        # Classification and indexing
        "classify_feature_tree",
        "discover_solidworks_docs",
    }
Methods:
execute async 
execute(operation: str, payload: object, call_args: tuple[Any, ...], call_kwargs: dict[str, Any], com_operation: OperationCallable, vba_operation: OperationCallable | None, cache_ttl_seconds: int | None = None) -> tuple[AdapterResult[Any], RouteResult]

Provide execute support for the intelligent router.

Parameters:

Name Type Description Default
operation str

Callable object executed by the helper.

 required
payload object

The payload value.

 required
call_args tuple[Any, ...]

The call args value.

 required
call_kwargs dict[str, Any]

The call kwargs value.

 required
com_operation OperationCallable

The com operation value.

 required
vba_operation OperationCallable | None

The vba operation value.

 required
cache_ttl_seconds int | None

The cache ttl seconds value. Defaults to None.

 None

Returns:

Type Description
tuple[AdapterResult[Any], RouteResult]

tuple[AdapterResult[Any], RouteResult]: A tuple containing the resulting values.
Source code in src/solidworks_mcp/adapters/intelligent_router.py 
 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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
async def execute(
    self,
    operation: str,
    payload: object,
    call_args: tuple[Any, ...],
    call_kwargs: dict[str, Any],
    com_operation: OperationCallable,
    vba_operation: OperationCallable | None,
    cache_ttl_seconds: int | None = None,
) -> tuple[AdapterResult[Any], RouteResult]:
    """Provide execute support for the intelligent router.

    Args:
        operation (str): Callable object executed by the helper.
        payload (object): The payload value.
        call_args (tuple[Any, ...]): The call args value.
        call_kwargs (dict[str, Any]): The call kwargs value.
        com_operation (OperationCallable): The com operation value.
        vba_operation (OperationCallable | None): The vba operation value.
        cache_ttl_seconds (int | None): The cache ttl seconds value. Defaults to None.

    Returns:
        tuple[AdapterResult[Any], RouteResult]: A tuple containing the resulting values.
    """
    if operation in self._cacheable_operations and self._cache.enabled:
        key = self._cache.make_key(operation, payload)
        cached = self._cache.get(key)
        if isinstance(cached, AdapterResult):
            return cached, RouteResult(route="cache", used_cache=True)

    decision = self._analyzer.analyze(operation=operation, payload=payload)

    if decision.prefer_vba and vba_operation is not None:
        vba_result = await self._safe_call(vba_operation, call_args, call_kwargs)
        self._analyzer.record_result(
            operation=operation,
            route="vba",
            success=vba_result.is_success,
        )
        if vba_result.is_success:
            self._cache_result(operation, payload, vba_result, cache_ttl_seconds)
            return vba_result, RouteResult(route="vba", used_cache=False)

    com_result = await self._safe_call(com_operation, call_args, call_kwargs)
    self._analyzer.record_result(
        operation=operation,
        route="com",
        success=com_result.is_success,
    )

    if com_result.is_success:
        self._cache_result(operation, payload, com_result, cache_ttl_seconds)
        return com_result, RouteResult(route="com", used_cache=False)

    if not decision.prefer_vba and vba_operation is not None:
        fallback_result = await self._safe_call(
            vba_operation,
            call_args,
            call_kwargs,
        )
        self._analyzer.record_result(
            operation=operation,
            route="vba",
            success=fallback_result.is_success,
        )
        if fallback_result.is_success:
            self._cache_result(
                operation,
                payload,
                fallback_result,
                cache_ttl_seconds,
            )
            return fallback_result, RouteResult(
                route="vba-fallback", used_cache=False
            )

    return com_result, RouteResult(route="com-error", used_cache=False)

MacroExecutionRequest dataclass 

MacroExecutionRequest(macro_code: str, macro_name: str, subroutine: str = 'Main')

Request to execute a VBA macro.

Attributes:

Name Type Description
macro_code str

The macro code value.
macro_name str

The macro name value.
subroutine str

The subroutine value.

MacroExecutionResult dataclass 

MacroExecutionResult(success: bool, macro_name: str, output: str | dict[str, Any] | None = None, error: str | None = None, duration_seconds: float = 0.0)

Result of VBA macro execution.

Attributes:

Name Type Description
duration_seconds float

The duration seconds value.
error str | None

The error value.
macro_name str

The macro name value.
output str | dict[str, Any] | None

The output value.
success bool

The success 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 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
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] = {}
    # Component tree for an Assembly-type current model, keyed by
    # component name. See ``_flatten_assembly_components`` for shape.
    # Empty means "use the canned default fixture" (see list_features).
    self._assembly_components: dict[str, dict[str, Any]] = {}
    self._sketches: dict[str, str] = {}
    self._current_sketch: str | None = None
    # Tracks IDs returned by add_line/add_arc/add_circle/add_centerline/
    # add_rectangle/add_spline so add_sketch_constraint can validate
    # entity1/entity2 the same way the real adapter validates against
    # its sketch-entity registry.
    self._sketch_entity_ids: set[str] = set()
    self._dimensions: dict[str, float] = {}
    # Assembly components inserted via insert_component, keyed by
    # insertion order. See insert_component/list_components/add_mate.
    self._components: list[str] = []
    self._operation_count = 0

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

Build internal getattribute.

Parameters:

Name Type Description Default
name str

The name value.

 required

Returns:

Name Type Description
Any Any

The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
166
167
168
169
170
171
172
173
174
175
176
177
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 
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
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
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 
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
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 
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
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 
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
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 
1017
1018
1019
1020
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
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Mock adding a line to sketch.

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

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

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

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=line_id,
        execution_time=self._delays["sketch_operation"] / 2,
    )
add_mate async 
add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0) -> AdapterResult[dict[str, Any]]

Mock mating two components in the active assembly.

Parameters:

Name Type Description Default
component_a str

First component instance name.

 required
component_b str

Second component instance name.

 required
entity_a str

Named feature on the first component. Defaults to "Front Plane".

 'Front Plane'
entity_b str

Named feature on the second component. Defaults to "Front Plane".

 'Front Plane'
mate_type str

Mate type. Defaults to "coincident".

 'coincident'
alignment str

Mate alignment. Defaults to "aligned".

 'aligned'
distance float

Distance in millimetres, for a distance mate. Defaults to 0.0.

 0.0
angle float

Angle in degrees, for an angle mate. Defaults to 0.0.

 0.0

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 
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
) -> AdapterResult[dict[str, Any]]:
    """Mock mating two components in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type. Defaults to "coincident".
        alignment (str): Mate alignment. Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: The result produced by the operation.
    """
    known_mate_types = {
        "coincident",
        "concentric",
        "perpendicular",
        "parallel",
        "tangent",
        "distance",
        "angle",
    }
    if mate_type not in known_mate_types:
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=(
                f"Unknown mate type '{mate_type}'. "
                f"Use one of: {', '.join(sorted(known_mate_types))}."
            ),
        )

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "mate_type": mate_type,
            "alignment": alignment,
            "components": [component_a, component_b],
            "entities": [entity_a, entity_b],
            "distance": distance or None,
            "angle": angle or None,
            # The real adapter fills these by comparing every component's
            # Transform2 before and after the mate. The mock has no
            # geometry to move, so it reports "not determinable" rather
            # than True: this field exists precisely so a caller can tell
            # a mate that positioned something from one SolidWorks
            # accepted and ignored, and a mock that always answers True
            # would make that check useless wherever mock mode is used.
            "moved_components": [],
            "geometry_moved": None,
        },
        execution_time=self._delays["model_operation"],
    )
add_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 
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
1287
1288
1289
1290
1291
1292
1293
1294
1295
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 
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
1220
1221
1222
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 
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
1574
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
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 
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
989
990
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 
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
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
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 
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
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 
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
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 
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
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 
668
669
670
671
672
673
674
675
676
677
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
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 
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
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 
744
745
746
747
748
749
750
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
788
789
790
791
792
793
794
795
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 
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
920
921
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 
625
626
627
628
629
630
631
632
633
634
635
636
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
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 
797
798
799
800
801
802
803
804
805
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
831
832
833
834
835
836
837
838
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 
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
950
951
952
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 
840
841
842
843
844
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
875
876
877
878
879
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 
195
196
197
198
199
200
201
202
203
204
205
206
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 
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
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 
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
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 
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
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 
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
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 
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
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 
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
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 
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
async def health_check(self) -> AdapterHealth:
    """Get mock health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    error_count = int(self._metrics["errors_count"])
    success_count = int(
        self._metrics["operations_count"] - self._metrics["errors_count"]
    )
    return AdapterHealth(
        healthy=self._connected,
        last_check=datetime.now(),
        error_count=error_count,
        success_count=success_count,
        average_response_time=self._metrics["average_response_time"],
        connection_status="connected" if self._connected else "disconnected",
        metrics={
            "adapter_type": "mock",
            "operations_count": self._operation_count,
            "models_count": len(self._models),
            "features_count": len(self._features),
            "sketches_count": len(self._sketches),
        },
    )
insert_component async 
insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Mock inserting a component into the active assembly.

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

Parameters:

Name Type Description Default
file_path str

Path to the part or sub-assembly to insert.

 required
x float

X position in millimetres. Defaults to 0.0.

 0.0
y float

Y position in millimetres. Defaults to 0.0.

 0.0
z float

Z position in millimetres. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Mock inserting a component into the active assembly.

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

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

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

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "component": self._components[-1],
            "file_path": file_path,
            "position": {"x": x, "y": y, "z": z},
            "components_before": len(self._components) - 1,
            "components_after": len(self._components),
        },
        execution_time=self._delays["model_operation"],
    )
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 
208
209
210
211
212
213
214
def is_connected(self) -> bool:
    """Check if mock connection is active.

    Returns:
        bool: True if connected, otherwise False.
    """
    return self._connected
list_components async 
list_components() -> AdapterResult[list[str]]

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

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
async def list_components(self) -> AdapterResult[list[str]]:
    """Mock listing the top-level components of the active assembly.

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

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

Mock configuration listing for the active model.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
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, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

Mock feature tree listing for the active model.

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

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False.

 False
max_assembly_depth int

Sub-assembly recursion budget. Ignored for non-Assembly models. Defaults to 2.

 2

Returns:

Type Description
AdapterResult[list[dict[str, Any]]]

AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
365
366
367
368
369
370
371
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
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
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
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """Mock feature tree listing for the active model.

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

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

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

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

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

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

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

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=feature_rows,
        execution_time=self._delays["feature_operation"] / 2,
    )
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 
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
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
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
    """Mock opening a SolidWorks model.

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

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

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

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

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

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

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

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

    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data=model,
        execution_time=self._delays["model_operation"],
    )
pack_and_go_assembly async 
pack_and_go_assembly(source_path: str, target_dir: str) -> AdapterResult[dict]

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

Parameters:

Name Type Description Default
source_path str

Path to the source .sldasm file.

 required
target_dir str

Directory to copy files into.

 required

Returns:

Type Description
AdapterResult[dict]

AdapterResult[dict]: Simulated pack-and-go result.
Source code in src/solidworks_mcp/adapters/mock_adapter.py 
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
async def pack_and_go_assembly(
    self,
    source_path: str,
    target_dir: str,
) -> AdapterResult[dict]:
    """Mock Pack-and-Go: simulate copying an assembly to a target directory.

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

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

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

    source = pathlib.Path(source_path)
    out_dir = pathlib.Path(target_dir)
    mock_parts = [f"MockPart{i}.SLDPRT" for i in range(1, 3)]
    source_files = [str(source)] + [str(source.parent / p) for p in mock_parts]
    copied_files = [str(out_dir / source.name)] + [
        str(out_dir / p) for p in mock_parts
    ]
    return AdapterResult(
        status=AdapterResultStatus.SUCCESS,
        data={
            "source_assembly": str(source),
            "target_dir": str(out_dir),
            "copied_files": copied_files,
            "source_files": source_files,
            "save_statuses": [0] * (len(mock_parts) + 1),
            "all_files_saved": True,
        },
        execution_time=0.05,
        metadata={"mock": True},
    )
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 
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
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 
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
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 
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
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 
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
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 
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
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
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 
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
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
1484
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 
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
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
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,
    )

PyWin32Adapter 

PyWin32Adapter(config: dict[str, Any] | None = None)

Bases: SolidWorksSketchMixin, SolidWorksFeaturesMixin, SolidWorksIOMixin, SolidWorksSelectionMixin, SolidWorksAdapter

SolidWorks adapter using pywin32 COM integration.

This adapter provides direct COM integration with SolidWorks using pywin32, enabling real-time automation and control of SolidWorks applications on Windows.

Parameters:

Name Type Description Default
config dict[str, Any] | None

Configuration values for the operation. Defaults to None.

 None

Raises:

Type Description
SolidWorksMCPError

PyWin32Adapter requires Windows platform.

Attributes:

Name Type Description
constants Any

The constants value.
Example 
adapter = PyWin32Adapter({'timeout': 30})
result = await adapter.connect()
if result.status == AdapterResultStatus.SUCCESS:
    print("Connected to SolidWorks successfully")

Initialize PyWin32Adapter with configuration.

Parameters:

Name Type Description Default
config dict[str, Any] | None

Configuration values for the operation. Defaults to None.

 None

Returns:

Name Type Description
None None

None.

Raises:

Type Description
SolidWorksMCPError

PyWin32Adapter requires Windows platform.
Example 
config = {
    "timeout": 30,
    "auto_connect": True,
    "startup_timeout": 60
}
adapter = PyWin32Adapter(config)
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
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
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
def __init__(self, config: dict[str, Any] | None = None) -> None:
    """Initialize PyWin32Adapter with configuration.

    Args:
        config (dict[str, Any] | None): Configuration values for the operation. Defaults to
                                        None.

    Returns:
        None: None.

    Raises:
        SolidWorksMCPError: PyWin32Adapter requires Windows platform.

    Example:
                        ```python
                        config = {
                            "timeout": 30,
                            "auto_connect": True,
                            "startup_timeout": 60
                        }
                        adapter = PyWin32Adapter(config)
                        ```
    """
    if not PYWIN32_AVAILABLE:  # pragma: no cover
        raise SolidWorksMCPError(
            "pywin32 is not available. Install with: pip install pywin32"
        )

    if platform.system() != "Windows":  # pragma: no cover
        raise SolidWorksMCPError("PyWin32Adapter requires Windows platform")

    super().__init__(config)

    self.swApp: Any | None = None
    self.currentModel: Any | None = None
    self.currentSketch: Any | None = None
    self.currentSketchManager: Any | None = None
    self._last_sketch_name: str | None = None
    self._sketch_count: int = 0  # incremented each time a sketch is created
    self._sketch_entities: dict[str, Any] = {}
    # Cached (center_x_mm, center_y_mm) for entities whose center can't be
    # recovered via ``GetCenterPoint`` — currently polygons, which register
    # as a SAFEARRAY of segment handles (no single dispatch to read from).
    # ``sketch_circular_pattern`` reads this to derive the seed-to-axis
    # offset for polygon seeds.
    self._sketch_entity_centers: dict[str, tuple[float, float]] = {}
    self._sketch_entity_counter = 0
    self._com_initialized = False

    # COM constants (equivalent to SolidWorks API constants)
    self.constants = {
        # Document types
        "swDocPART": 1,
        "swDocASSEMBLY": 2,
        "swDocDRAWING": 3,
        # Selection types
        "swSelFACES": 1,
        "swSelEDGES": 2,
        "swSelVERTICES": 3,
        "swSelSKETCHSEGS": 4,
        "swSelSKETCHPOINTS": 5,
        "swSelDATUMPLANES": 6,
        # Feature end conditions
        "swEndCondBlind": 0,
        "swEndCondThroughAll": 1,
        "swEndCondUpToNext": 2,
        "swEndCondUpToSurface": 3,
        "swEndCondOffset": 4,
        "swEndCondUpToVertex": 5,
        "swEndCondMidPlane": 6,
        "swEndCondThroughAllBoth": 9,
        # Dimension preferences / directions
        "swInputDimValOnCreate": 10,
        "swSketchAcceptNumericInput": 372,
        "swSketchCreateDimensionOnlyWhenEntered": 520,
        "swScaleSketchOnFirstDimension": 642,
        "swSmartDimensionDirectionRight": 0,
        "swSmartDimensionDirectionUp": 1,
        "swSmartDimensionDirectionLeft": 2,
        "swSmartDimensionDirectionDown": 3,
    }

    self._session_coordinator = _ComSessionCoordinator(self)
    self._sketch_geometry = _SketchGeometryService(self)
    self._document_routing = _DocumentRoutingService(self)
    self._feature_selector = _FeatureSelectionService(self)
Methods:
connect async 
connect() -> None

Connect to SolidWorks COM and prepare automation-safe session state.

Raises:

Type Description
SolidWorksMCPError

If connection or readiness checks fail.
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
1727
1728
1729
1730
1731
1732
1733
async def connect(self) -> None:
    """Connect to SolidWorks COM and prepare automation-safe session state.

    Raises:
        SolidWorksMCPError: If connection or readiness checks fail.
    """
    await self._session_coordinator.connect()
disconnect async 
disconnect() -> None

Disconnect from SolidWorks application.

Properly disconnects from SolidWorks COM interface and cleans up resources. This method should always be called when finished to prevent memory leaks.

Note: - Clears references to current model and application - Uninitialize COM apartment - Does not close SolidWorks application itself

Returns:

Name Type Description
None None

None.
Example 
try:
    await adapter.connect()
    # ... do work ...
finally:
    await adapter.disconnect()
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
async def disconnect(self) -> None:
    """Disconnect from SolidWorks application.

    Properly disconnects from SolidWorks COM interface and cleans up resources. This method
    should always be called when finished to prevent memory leaks.

    Note: - Clears references to current model and application - Uninitialize COM apartment
    - Does not close SolidWorks application itself

    Returns:
        None: None.

    Example:
                        ```python
                        try:
                            await adapter.connect()
                            # ... do work ...
                        finally:
                            await adapter.disconnect()
                        ```
    """
    await self._session_coordinator.disconnect()
execute_macro async 
execute_macro(params: dict[str, Any]) -> AdapterResult[dict[str, Any]]

Provide execute macro support for the py win32 adapter.

Parameters:

Name Type Description Default
params dict[str, Any]

The params value.

 required

Returns:

Type Description
AdapterResult[dict[str, Any]]

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

Raises:

Type Description
SolidWorksMCPError

If the operation cannot be completed.
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
async def execute_macro(
    self, params: dict[str, Any]
) -> AdapterResult[dict[str, Any]]:
    """Provide execute macro support for the py win32 adapter.

    Args:
        params (dict[str, Any]): The params value.

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

    Raises:
        SolidWorksMCPError: If the operation cannot be completed.
    """
    macro_path = params.get("macro_path") or params.get("macro_file") or ""
    if not macro_path:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No macro_path provided"
        )
    if not os.path.isfile(macro_path):
        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"Macro file not found: {macro_path}",
        )

    def _run() -> dict[str, Any]:
        """Resolve module/proc names and delegate to _invoke_run_macro2.

        Returns:
            dict[str, Any]: A dictionary containing the resulting values.

        Raises:
            SolidWorksMCPError: If the operation cannot be completed.
        """
        module_name = _parse_vb_module_name(macro_path)
        proc_name = params.get("proc_name", "main")
        return self._invoke_run_macro2(macro_path, module_name, proc_name)

    return self._handle_com_operation("execute_macro", _run)
export_file 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.

Raises:

Type Description
Exception

If the operation cannot be completed.
RuntimeError

No active SolidWorks document for export.
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
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.

    Raises:
        Exception: If the operation cannot be completed.
        RuntimeError: No active SolidWorks document for export.
    """
    if not self.currentModel:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )

    def _export_operation() -> None:
        """Build internal export operation.

        Returns:
            None: None.

        Raises:
            Exception: If the operation cannot be completed.
            RuntimeError: No active SolidWorks document for export.
        """
        format_map = {
            "step": 0,  # swSaveAsSTEP
            "iges": 1,  # swSaveAsIGS
            "stl": 2,  # swSaveAsSTL
            "pdf": 3,  # swSaveAsPDF
            "dwg": 4,  # swSaveAsDWG
            "jpg": 5,  # swSaveAsJPEG
            "glb": 41,  # swSaveAsGLTF (binary GLTF, SW 2023+)
            "gltf": 41,  # same enum value, text GLTF
        }

        format_lower = format_type.lower()
        if format_lower not in format_map:
            raise Exception(f"Unsupported export format: {format_type}")

        resolved_path = os.path.abspath(file_path)
        os.makedirs(os.path.dirname(resolved_path), exist_ok=True)

        if os.path.exists(resolved_path):
            self._attempt(lambda: os.remove(resolved_path))

        # Prefer swApp.ActiveDoc — more reliably typed than the late-bound
        # IDispatch reference stored in self.currentModel after OpenDoc6.
        # Use getattr so tests can pass a SimpleNamespace without ActiveDoc.
        target_doc = (
            getattr(self.swApp, "ActiveDoc", None) if self.swApp else None
        ) or self.currentModel

        # ----------------------------------------------------------------
        # STL export: use Extension.SaveAs2 + ISTLExportData
        # for both parts AND assemblies.  SaveAs3 with format=2 works for
        # parts but is unreliable for assemblies (only exports first body).
        # ----------------------------------------------------------------
        if format_lower == "stl":
            # For assemblies, resolve lightweight components first so all
            # geometry is available for the mesh export.
            self._attempt(lambda: target_doc.ResolveAllLightweightComponents(True))  # type: ignore[union-attr]

            ext = getattr(target_doc, "Extension", None)
            if ext is None:
                raise RuntimeError("No Extension object available for STL export")

            stl_data = self._prepare_stl_export_data()
            if not self._save_stl_with_extension(ext, stl_data, resolved_path):
                # SaveAs2 didn't produce file — try SaveAs3 fallback
                self._save_stl_with_fallback(target_doc, resolved_path)

            return None

        # ----------------------------------------------------------------
        # All other formats — classic SaveAs3 path.
        # SaveAs3 signature: SaveAs3(FileName, Version, Options)
        # Version = 0 means "current version" (swSaveAsCurrentVersion).
        # SolidWorks infers the export format from the file extension, so
        # we must NOT pass the format-enum value as the Version argument.
        # ----------------------------------------------------------------
        _ = format_map[format_lower]  # validate format is known; value unused
        logger.debug(
            "[pywin32.export_file] SaveAs3 {} (version=0, options=Silent)",
            resolved_path,
        )
        success = target_doc.SaveAs3(  # type: ignore[union-attr]
            resolved_path,
            0,  # swSaveAsCurrentVersion — format inferred from file extension
            2,  # swSaveAsOptions_Silent
        )

        if not success and not os.path.exists(resolved_path):
            raise Exception(
                f"SaveAs3 returned False and no file produced: {resolved_path}"
            )

        return None

    return self._handle_com_operation("export_file", _export_operation)
export_image async 
export_image(payload: dict) -> AdapterResult[dict]

Export a screenshot of the current model to a PNG/JPG file.

Payload keys (matching ExportImageInput): file_path (str): Output path including extension. format_type (str): "png" or "jpg". Default "png". width (int): Pixel width. Default 1280. height (int): Pixel height. Default 720. view_orientation (str): "front" | "top" | "right" | "isometric" | "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.

Raises:

Type Description
RuntimeError

If the operation cannot be completed.
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
async def export_image(self, payload: dict) -> AdapterResult[dict]:
    """Export a screenshot of the current model to a PNG/JPG file.

    Payload keys (matching ExportImageInput): file_path (str): Output path including
    extension. format_type (str): "png" or "jpg". Default "png". width (int): Pixel width.
    Default 1280. height (int): Pixel height. Default 720. view_orientation (str): "front" |
    "top" | "right" | "isometric" | "current".

    Args:
        payload (dict): The payload value.

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

    Raises:
        RuntimeError: If the operation cannot be completed.
    """
    if not self.currentModel:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="No active model"
        )
    if not self.swApp:
        return AdapterResult(
            status=AdapterResultStatus.ERROR, error="SolidWorks not connected"
        )

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

    # Map orientation names to SolidWorks swStandardViews_e constants
    _VIEW_CONSTANTS = {
        "front": 1,  # swFrontView
        "back": 2,  # swBackView
        "left": 3,  # swLeftView
        "right": 4,  # swRightView
        "top": 5,  # swTopView
        "bottom": 6,  # swBottomView
        "isometric": 7,  # swIsometricView
        "dimetric": 8,  # swDimetricView
        "trimetric": 9,  # swTriMetricView
    }

    def _screenshot_operation() -> dict:
        """Build internal screenshot operation.

        Returns:
            dict: A dictionary containing the resulting values.

        Raises:
            RuntimeError: If the operation cannot be completed.
        """

        import os as _os

        resolved = _os.path.abspath(file_path)
        _os.makedirs(_os.path.dirname(resolved), exist_ok=True)

        target_doc = self._resolve_export_target_doc()

        # Ensure SolidWorks window is focused so the viewport is rendered.
        # Required for both view changes and bitmap capture.
        self._attempt(lambda: self.swApp.Frame.SetFocus())  # type: ignore[union-attr]

        # Set view orientation if requested
        if orientation != "current" and orientation in _VIEW_CONSTANTS:
            view_const = _VIEW_CONSTANTS[orientation]
            self._set_view_orientation(target_doc, orientation, view_const)

        # Zoom to fit so the model fills the viewport before capture
        self._zoom_to_fit(target_doc)

        # Remove any pre-existing file so SolidWorks never shows the
        # "already exists — replace?" confirmation dialog.
        if _os.path.exists(resolved):  # pragma: no cover
            _os.remove(resolved)

        # Try screenshot methods in order: ModelView → TargetDoc → SaveAs3
        saved = self._save_screenshot_with_modelview(
            target_doc, resolved, width, height
        )
        if not saved:
            saved = self._save_screenshot_with_targetdoc(
                target_doc, resolved, width, height
            )
        if not saved:
            self._save_screenshot_with_saveas3(target_doc, resolved)
            saved = _os.path.exists(resolved)

        if not saved:
            raise RuntimeError(
                f"All screenshot methods produced no output for {resolved}"
            )

        return {
            "file_path": resolved,
            "format": _os.path.splitext(resolved)[1].lstrip(".").upper() or "PNG",
            "dimensions": f"{width}x{height}",
            "view": orientation,
        }

    return self._handle_com_operation("export_image", _screenshot_operation)
health_check async 
health_check() -> AdapterHealth

Get adapter health status.

Performs comprehensive health check including connection status, operation metrics, and SolidWorks application responsiveness.

Returns:

Name Type Description
AdapterHealth AdapterHealth

The result produced by the operation.
Example 
health = await adapter.health_check()
if health.healthy:
    print(f"Adapter healthy, {health.success_count} operations completed")
else:
    print(f"Adapter unhealthy: {health.error_count} errors")
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
async def health_check(self) -> AdapterHealth:
    """Get adapter health status.

    Performs comprehensive health check including connection status, operation metrics, and
    SolidWorks application responsiveness.

    Returns:
        AdapterHealth: The result produced by the operation.

    Example:
                        ```python
                        health = await adapter.health_check()
                        if health.healthy:
                            print(f"Adapter healthy, {health.success_count} operations completed")
                        else:
                            print(f"Adapter unhealthy: {health.error_count} errors")
                        ```
    """
    healthy = self.is_connected()

    # Support both callable COM method and property-style RevisionNumber.
    sw_version: str | None = None
    if self.swApp:
        sw_version = self._attempt(
            lambda: self._get_attr_or_call(self.swApp, "RevisionNumber")
        )

    # Try a simple operation to verify connection
    if healthy:
        healthy = sw_version is not None

    return AdapterHealth(
        healthy=healthy,
        last_check=datetime.now(),
        error_count=int(self._metrics["errors_count"]),
        success_count=int(
            self._metrics["operations_count"] - self._metrics["errors_count"]
        ),
        average_response_time=self._metrics["average_response_time"],
        connection_status="connected" if healthy else "disconnected",
        metrics={
            "adapter_type": "pywin32",
            "sw_version": sw_version or "Unknown",
            "current_model": self.currentModel.GetTitle()
            if self.currentModel
            else None,
        },
    )
is_connected 
is_connected() -> bool

Check if connected to SolidWorks.

Returns:

Name Type Description
bool bool

True if connected, otherwise False.
Example 
if adapter.is_connected():
    print("Ready to automate SolidWorks")
else:
    await adapter.connect()
Source code in src/solidworks_mcp/adapters/pywin32_adapter.py 
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
def is_connected(self) -> bool:
    """Check if connected to SolidWorks.

    Returns:
        bool: True if connected, otherwise False.

    Example:
                        ```python
                        if adapter.is_connected():
                            print("Ready to automate SolidWorks")
                        else:
                            await adapter.connect()
                        ```
    """
    return self.swApp is not None

RoutingDecision

Bases: BaseModel

Complexity-based routing decision.

Attributes:

Name Type Description
complexity_score float

The complexity score value.
operation str

The operation value.
parameter_count int

The parameter count value.
prefer_vba bool

The prefer vba value.
reason str

The reason value.

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 
319
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
def __init__(self, config: object | None = None):
    """Initialize adapter with configuration.

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

    # Preserve original config object for compatibility with tests and
    # call sites that compare object identity/equality.
    self.config = config
    # Keep a normalized mapping for adapter internals.
    self.config_dict = normalized_config
    self._metrics = {
        "operations_count": 0,
        "errors_count": 0,
        "average_response_time": 0.0,
    }
    # SolidWorks-as-Code session logging. Set soc_session_id to enable
    # automatic ToolCallRecord writes for every adapter operation.
    self.soc_session_id: str | None = None
    self.soc_db_path: Path | None = None
Methods:
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 
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
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 
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
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 
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
@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 
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_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 
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
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 
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
@abstractmethod
async def add_line(
    self, x1: float, y1: float, x2: float, y2: float
) -> AdapterResult[str]:
    """Add a line to the current sketch.

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

    Returns:
        AdapterResult[str]: The result produced by the operation.
    """
    pass
add_mate async 
add_mate(component_a: str, component_b: str, entity_a: str = 'Front Plane', entity_b: str = 'Front Plane', mate_type: str = 'coincident', alignment: str = 'aligned', distance: float = 0.0, angle: float = 0.0) -> AdapterResult[dict[str, Any]]

Mate two components together in the active assembly.

Parameters:

Name Type Description Default
component_a str

First component instance name.

 required
component_b str

Second component instance name.

 required
entity_a str

Named feature on the first component. Defaults to "Front Plane".

 'Front Plane'
entity_b str

Named feature on the second component. Defaults to "Front Plane".

 'Front Plane'
mate_type str

Mate type, e.g. coincident. Defaults to "coincident".

 'coincident'
alignment str

aligned, anti_aligned or closest. Defaults to "aligned".

 'aligned'
distance float

Distance in millimetres, for a distance mate. Defaults to 0.0.

 0.0
angle float

Angle in degrees, for an angle mate. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: Mate details, or error.
Source code in src/solidworks_mcp/adapters/base.py 
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
async def add_mate(
    self,
    component_a: str,
    component_b: str,
    entity_a: str = "Front Plane",
    entity_b: str = "Front Plane",
    mate_type: str = "coincident",
    alignment: str = "aligned",
    distance: float = 0.0,
    angle: float = 0.0,
) -> AdapterResult[dict[str, Any]]:
    """Mate two components together in the active assembly.

    Args:
        component_a (str): First component instance name.
        component_b (str): Second component instance name.
        entity_a (str): Named feature on the first component. Defaults to
            "Front Plane".
        entity_b (str): Named feature on the second component. Defaults to
            "Front Plane".
        mate_type (str): Mate type, e.g. ``coincident``. Defaults to
            "coincident".
        alignment (str): ``aligned``, ``anti_aligned`` or ``closest``.
            Defaults to "aligned".
        distance (float): Distance in millimetres, for a distance mate.
            Defaults to 0.0.
        angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: Mate details, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="add_mate is not implemented by this adapter",
    )
add_polygon async 
add_polygon(center_x: float, center_y: float, radius: float, sides: int) -> AdapterResult[str]

Add a regular polygon to the current sketch.

Parameters:

Name Type Description Default
center_x float

The center x value.

 required
center_y float

The center y value.

 required
radius float

The radius value.

 required
sides int

The sides value.

 required

Returns:

Type Description
AdapterResult[str]

AdapterResult[str]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
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 
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
@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 
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
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 
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
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 
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
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 
667
668
669
670
671
672
673
674
675
676
677
678
679
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 
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
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 
399
400
401
402
403
404
405
406
407
408
409
@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 
350
351
352
353
354
355
356
357
@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 
492
493
494
495
496
497
498
499
500
501
502
503
504
@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 
915
916
917
918
919
920
921
922
923
924
925
926
927
928
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 
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
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 
506
507
508
509
510
511
512
513
514
515
516
517
518
@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 
521
522
523
524
525
526
527
528
529
530
531
532
533
@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 
563
564
565
566
567
568
569
570
571
572
573
574
575
@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 
477
478
479
480
481
482
483
484
485
486
487
488
489
490
@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 
535
536
537
538
539
540
541
542
543
544
545
546
547
@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 
578
579
580
581
582
583
584
585
586
587
588
@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 
549
550
551
552
553
554
555
556
557
558
559
560
561
@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 
359
360
361
362
363
364
365
366
@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 
1035
1036
1037
1038
1039
1040
1041
1042
@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 
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
@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 
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
@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 
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
@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 
1045
1046
1047
1048
1049
1050
1051
1052
@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 
1134
1135
1136
1137
1138
1139
1140
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 
425
426
427
428
429
430
431
432
@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 
377
378
379
380
381
382
383
384
@abstractmethod
async def health_check(self) -> AdapterHealth:
    """Get adapter health status.

    Returns:
        AdapterHealth: The result produced by the operation.
    """
    pass
insert_component async 
insert_component(file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> AdapterResult[dict[str, Any]]

Insert a part or sub-assembly into the active assembly.

Parameters:

Name Type Description Default
file_path str

Absolute path to the .sldprt or .sldasm.

 required
x float

X position in millimetres. Defaults to 0.0.

 0.0
y float

Y position in millimetres. Defaults to 0.0.

 0.0
z float

Z position in millimetres. Defaults to 0.0.

 0.0

Returns:

Type Description
AdapterResult[dict[str, Any]]

AdapterResult[dict[str, Any]]: Component name and counts, or error.
Source code in src/solidworks_mcp/adapters/base.py 
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
async def insert_component(
    self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
) -> AdapterResult[dict[str, Any]]:
    """Insert a part or sub-assembly into the active assembly.

    Args:
        file_path (str): Absolute path to the ``.sldprt`` or ``.sldasm``.
        x (float): X position in millimetres. Defaults to 0.0.
        y (float): Y position in millimetres. Defaults to 0.0.
        z (float): Z position in millimetres. Defaults to 0.0.

    Returns:
        AdapterResult[dict[str, Any]]: Component name and counts, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="insert_component is not implemented by this adapter",
    )
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 
368
369
370
371
372
373
374
375
@abstractmethod
def is_connected(self) -> bool:
    """Check if connected to SolidWorks.

    Returns:
        bool: True if connected, otherwise False.
    """
    pass
list_components async 
list_components() -> AdapterResult[list[str]]

List the top-level components of the active assembly.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: Component instance names, or error.
Source code in src/solidworks_mcp/adapters/base.py 
988
989
990
991
992
993
994
995
996
997
async def list_components(self) -> AdapterResult[list[str]]:
    """List the top-level components of the active assembly.

    Returns:
        AdapterResult[list[str]]: Component instance names, or error.
    """
    return AdapterResult(
        status=AdapterResultStatus.ERROR,
        error="list_components is not implemented by this adapter",
    )
list_configurations abstractmethod async 
list_configurations() -> AdapterResult[list[str]]

List configuration names for the active model.

Returns:

Type Description
AdapterResult[list[str]]

AdapterResult[list[str]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
468
469
470
471
472
473
474
475
@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, max_assembly_depth: int = 2) -> AdapterResult[list[dict[str, Any]]]

List model features from the feature tree.

For a Part document, returns that document's own feature list, unchanged from prior behavior. For an Assembly document, returns a single flat list containing the assembly's own top-level features plus every resolved component's features, recursing into sub-assemblies up to max_assembly_depth. Every descriptor gains component, component_path, and component_parent keys: None for a document's own features (Part features, or an Assembly's top-level features), or the owning component's name/path for a component-derived feature. component_parent is the immediate parent component name when the component is nested inside a sub-assembly, otherwise None. A component that cannot be resolved (suppressed, lightweight-and-unloaded, missing file) is represented by one descriptor with type: "UnresolvedComponent" instead of being silently dropped.

Parameters:

Name Type Description Default
include_suppressed bool

The include suppressed value. Defaults to False. Applied independently to the assembly's own features and to each component's features.

 False
max_assembly_depth int

How many levels of sub-assembly to recurse into. Defaults to 2. Ignored for Part documents. A component beyond the configured depth still appears in the result as a single descriptor (name + path), not expanded.

 2

Returns:

Type Description
AdapterResult[list[dict[str, Any]]]

AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/base.py 
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
464
465
466
@abstractmethod
async def list_features(
    self, include_suppressed: bool = False, max_assembly_depth: int = 2
) -> AdapterResult[list[dict[str, Any]]]:
    """List model features from the feature tree.

    For a Part document, returns that document's own feature list,
    unchanged from prior behavior. For an Assembly document, returns a
    single flat list containing the assembly's own top-level features
    plus every resolved component's features, recursing into
    sub-assemblies up to ``max_assembly_depth``. Every descriptor gains
    ``component``, ``component_path``, and ``component_parent`` keys:
    ``None`` for a document's own features (Part features, or an Assembly's
    top-level features), or the owning component's name/path for a
    component-derived feature. ``component_parent`` is the immediate parent
    component name when the component is nested inside a sub-assembly,
    otherwise ``None``. A component that cannot be resolved (suppressed,
    lightweight-and-unloaded, missing file) is represented by one descriptor
    with ``type: "UnresolvedComponent"`` instead of being silently dropped.

    Args:
        include_suppressed (bool): The include suppressed value. Defaults to False.
            Applied independently to the assembly's own features and to
            each component's features.
        max_assembly_depth (int): How many levels of sub-assembly to
            recurse into. Defaults to 2. Ignored for Part documents. A
            component beyond the configured depth still appears in the
            result as a single descriptor (name + path), not expanded.

    Returns:
        AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
    """
    pass
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 
387
388
389
390
391
392
393
394
395
396
397
@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 
411
412
413
414
415
416
417
418
419
420
421
422
423
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 
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
@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 
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
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 
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
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 
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
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 
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
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 
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
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

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)
Methods:
__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())

VbaMacroExecutor 

VbaMacroExecutor(temp_macro_dir: Path | None = None)

Manage VBA macro execution with save and tracking.

This executor handles the full lifecycle: code generation, on-disk persistence, execution via the backing adapter, and result tracking.

Parameters:

Name Type Description Default
temp_macro_dir Path | None

The temp macro dir value. Defaults to None.

 None

Attributes:

Name Type Description
_temp_macro_dir Any

The temp macro dir value.

Initialize macro executor.

Parameters:

Name Type Description Default
temp_macro_dir Path | None

The temp macro dir value. Defaults to None.

 None

Returns:

Name Type Description
None None

None.
Source code in src/solidworks_mcp/adapters/vba_macro_executor.py 
61
62
63
64
65
66
67
68
69
70
71
def __init__(self, temp_macro_dir: Path | None = None) -> None:
    """Initialize macro executor.

    Args:
        temp_macro_dir (Path | None): The temp macro dir value. Defaults to None.

    Returns:
        None: None.
    """
    self._temp_macro_dir = temp_macro_dir or Path(tempfile.gettempdir())
    self._execution_history: dict[str, MacroExecutionResult] = {}
Methods:
execute_macro async 
execute_macro(request: MacroExecutionRequest, backing_adapter: Any) -> AdapterResult[MacroExecutionResult]

Provide execute macro support for the vba macro executor.

Parameters:

Name Type Description Default
request MacroExecutionRequest

The request value.

 required
backing_adapter Any

The backing adapter value.

 required

Returns:

Type Description
AdapterResult[MacroExecutionResult]

AdapterResult[MacroExecutionResult]: The result produced by the operation.
Source code in src/solidworks_mcp/adapters/vba_macro_executor.py 
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
async def execute_macro(
    self,
    request: MacroExecutionRequest,
    backing_adapter: Any,
) -> AdapterResult[MacroExecutionResult]:
    """Provide execute macro support for the vba macro executor.

    Args:
        request (MacroExecutionRequest): The request value.
        backing_adapter (Any): The backing adapter value.

    Returns:
        AdapterResult[MacroExecutionResult]: The result produced by the operation.
    """
    start_time = datetime.utcnow()
    macro_path = self._save_macro_to_disk(request.macro_code, request.macro_name)

    try:
        result = await self._execute_via_adapter(
            macro_path=macro_path,
            subroutine=request.subroutine,
            backing_adapter=backing_adapter,
        )

        duration = (datetime.utcnow() - start_time).total_seconds()
        execution_result = MacroExecutionResult(
            success=result.get("success", False),
            macro_name=request.macro_name,
            output=result.get("output"),
            error=result.get("error"),
            duration_seconds=duration,
        )

        self._execution_history[request.macro_name] = execution_result

        return AdapterResult(
            status=AdapterResultStatus.SUCCESS,
            data=execution_result,
            metadata={
                "macro_path": str(macro_path),
                "macro_name": request.macro_name,
                "duration_seconds": duration,
                "subroutine": request.subroutine,
            },
        )

    except Exception as exc:
        duration = (datetime.utcnow() - start_time).total_seconds()
        execution_result = MacroExecutionResult(
            success=False,
            macro_name=request.macro_name,
            error=str(exc),
            duration_seconds=duration,
        )

        self._execution_history[request.macro_name] = execution_result

        return AdapterResult(
            status=AdapterResultStatus.ERROR,
            error=f"macro execution failed: {exc}",
        )
get_execution_history 
get_execution_history(macro_name: str | None = None) -> dict[str, MacroExecutionResult]

Retrieve 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, MacroExecutionResult]

dict[ str, MacroExecutionResult,
dict[str, MacroExecutionResult]

]: A dictionary containing the resulting values.
Source code in src/solidworks_mcp/adapters/vba_macro_executor.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
def get_execution_history(
    self, macro_name: str | None = None
) -> dict[
    str,
    MacroExecutionResult,
]:
    """Retrieve macro execution history.

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

    Returns:
        dict[
            str,
            MacroExecutionResult,
        ]: A dictionary containing the
                                                                resulting values.
    """
    if macro_name is not None:
        return (
            {
                macro_name: self._execution_history[macro_name],
            }
            if macro_name in self._execution_history
            else {}
        )
    return dict(self._execution_history)

Functions:

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