solidworks-mcp-python 1.5.0__py3-none-any.whl

solidworks_mcp/tools/sketching.py

@@ -0,0 +1,1422 @@
+"""Sketching tools for SolidWorks MCP Server.
+
+Provides tools for creating and editing sketches, including geometric entities like
+lines, circles, rectangles, arcs, and constraints.
+"""
+
+from typing import Any, TypeVar
+
+from fastmcp import FastMCP
+from pydantic import BaseModel, Field
+
+from ..adapters.base import SolidWorksAdapter
+from .input_compat import CompatInput
+from .tool_boundary import (
+    normalize_input,
+    require_success,
+    with_tool_boundary,
+)
+
+TInput = TypeVar("TInput", bound=BaseModel)
+
+
+# Input schemas using Python 3.14 built-in types
+
+
+class CreateSketchInput(CompatInput):
+    """Input schema for creating a sketch.
+
+    Attributes:
+        plane (str): The plane value.
+        sketch_name (str | None): The sketch name value.
+    """
+
+    plane: str = Field(
+        description="Sketch plane name (e.g., 'Top', 'Front', 'Right', 'XY', 'XZ', 'YZ')"
+    )
+    sketch_name: str | None = Field(default=None, description="Sketch name alias")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the create sketch input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+
+        Raises:
+            ValueError: Plane is required.
+        """
+        if not self.plane.strip():
+            raise ValueError("plane is required")
+
+
+class AddLineInput(CompatInput):
+    """Input schema for adding a line to sketch.
+
+    Attributes:
+        construction (bool): The construction value.
+        end_x (float | None): The end x value.
+        end_y (float | None): The end y value.
+        start_x (float | None): The start x value.
+        start_y (float | None): The start y value.
+        x1 (float | None): The x1 value.
+        x2 (float | None): The x2 value.
+        y1 (float | None): The y1 value.
+        y2 (float | None): The y2 value.
+    """
+
+    x1: float | None = Field(default=None, description="Start point X coordinate in mm")
+    y1: float | None = Field(default=None, description="Start point Y coordinate in mm")
+    x2: float | None = Field(default=None, description="End point X coordinate in mm")
+    y2: float | None = Field(default=None, description="End point Y coordinate in mm")
+    start_x: float | None = Field(default=None, description="Start point X alias")
+    start_y: float | None = Field(default=None, description="Start point Y alias")
+    end_x: float | None = Field(default=None, description="End point X alias")
+    end_y: float | None = Field(default=None, description="End point Y alias")
+    construction: bool = Field(default=False, description="Construction geometry flag")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the add line input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        self.x1 = self.x1 if self.x1 is not None else self.start_x
+        self.y1 = self.y1 if self.y1 is not None else self.start_y
+        self.x2 = self.x2 if self.x2 is not None else self.end_x
+        self.y2 = self.y2 if self.y2 is not None else self.end_y
+
+
+class AddCircleInput(CompatInput):
+    """Input schema for adding a circle to sketch.
+
+    Attributes:
+        center_x (float): The center x value.
+        center_y (float): The center y value.
+        construction (bool): The construction value.
+        radius (float): The radius value.
+    """
+
+    center_x: float = Field(description="Circle center X coordinate in mm")
+    center_y: float = Field(description="Circle center Y coordinate in mm")
+    radius: float = Field(description="Circle radius in mm")
+    construction: bool = Field(default=False, description="Construction geometry flag")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the add circle input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+
+        Raises:
+            ValueError: Radius must be positive.
+        """
+        if self.radius <= 0:
+            raise ValueError("radius must be positive")
+
+
+class AddRectangleInput(CompatInput):
+    """Input schema for adding a rectangle to sketch.
+
+    Attributes:
+        construction (bool): The construction value.
+        corner1_x (float | None): The corner1 x value.
+        corner1_y (float | None): The corner1 y value.
+        corner2_x (float | None): The corner2 x value.
+        corner2_y (float | None): The corner2 y value.
+        x1 (float | None): The x1 value.
+        x2 (float | None): The x2 value.
+        y1 (float | None): The y1 value.
+        y2 (float | None): The y2 value.
+    """
+
+    x1: float | None = Field(
+        default=None, description="First corner X coordinate in mm"
+    )
+    y1: float | None = Field(
+        default=None, description="First corner Y coordinate in mm"
+    )
+    x2: float | None = Field(
+        default=None, description="Opposite corner X coordinate in mm"
+    )
+    y2: float | None = Field(
+        default=None, description="Opposite corner Y coordinate in mm"
+    )
+    corner1_x: float | None = Field(default=None, description="Corner 1 X alias")
+    corner1_y: float | None = Field(default=None, description="Corner 1 Y alias")
+    corner2_x: float | None = Field(default=None, description="Corner 2 X alias")
+    corner2_y: float | None = Field(default=None, description="Corner 2 Y alias")
+    construction: bool = Field(default=False, description="Construction geometry flag")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the add rectangle input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+
+        Raises:
+            ValueError: Rectangle corners must differ.
+        """
+        self.x1 = self.x1 if self.x1 is not None else self.corner1_x
+        self.y1 = self.y1 if self.y1 is not None else self.corner1_y
+        self.x2 = self.x2 if self.x2 is not None else self.corner2_x
+        self.y2 = self.y2 if self.y2 is not None else self.corner2_y
+        if (
+            None not in (self.x1, self.y1, self.x2, self.y2)
+            and self.x1 == self.x2
+            and self.y1 == self.y2
+        ):
+            raise ValueError("rectangle corners must differ")
+
+
+class AddArcInput(BaseModel):
+    """Input schema for adding an arc to sketch.
+
+    Attributes:
+        center_x (float): The center x value.
+        center_y (float): The center y value.
+        end_x (float): The end x value.
+        end_y (float): The end y value.
+        start_x (float): The start x value.
+        start_y (float): The start y value.
+    """
+
+    center_x: float = Field(description="Arc center X coordinate in mm")
+    center_y: float = Field(description="Arc center Y coordinate in mm")
+    start_x: float = Field(description="Arc start point X coordinate in mm")
+    start_y: float = Field(description="Arc start point Y coordinate in mm")
+    end_x: float = Field(description="Arc end point X coordinate in mm")
+    end_y: float = Field(description="Arc end point Y coordinate in mm")
+
+
+class AddSplineInput(BaseModel):
+    """Input schema for adding a spline to sketch.
+
+    Attributes:
+        points (list[dict[str, float]]): The points value.
+    """
+
+    points: list[dict[str, float]] = Field(
+        description="List of spline control points with x, y coordinates"
+    )
+
+
+class AddDimensionInput(BaseModel):
+    """Input schema for adding a dimension to sketch.
+
+    Attributes:
+        dimension_type (str): The dimension type value.
+        entity1 (str): The entity1 value.
+        entity2 (str | None): The entity2 value.
+        value (float): The value value.
+    """
+
+    entity1: str = Field(description="First entity name or ID")
+    entity2: str | None = Field(
+        default=None, description="Second entity name or ID (for distance dimensions)"
+    )
+    dimension_type: str = Field(
+        default="linear", description="Dimension type (linear, radial, angular, etc.)"
+    )
+    value: float = Field(description="Dimension value in mm or degrees")
+
+
+class AddRelationInput(BaseModel):
+    """Input schema for adding a geometric relation.
+
+    Attributes:
+        entity1 (str): The entity1 value.
+        entity2 (str | None): The entity2 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``.
+        relation_type (str): The relation type value.
+    """
+
+    entity1: str = Field(description="First entity name or ID")
+    entity2: str | None = Field(
+        default=None, description="Second entity name or ID (if required)"
+    )
+    entity3: str | None = Field(
+        default=None,
+        description=(
+            "Third entity ID. Required for 'symmetric' (the centerline of "
+            "symmetry); must be null for all other relations."
+        ),
+    )
+    relation_type: str = Field(
+        description="Relation type (parallel, perpendicular, tangent, coincident, etc.)"
+    )
+
+
+class TutorialSimpleHoleInput(CompatInput):
+    """Input schema for creating a simple hole (tutorial example).
+
+    Attributes:
+        center_x (float): The center x value.
+        center_y (float): The center y value.
+        depth (float | None): The depth value.
+        diameter (float): The diameter value.
+        plane (str): The plane value.
+    """
+
+    plane: str = Field(description="Sketch plane for the hole")
+    center_x: float = Field(description="Hole center X coordinate in mm")
+    center_y: float = Field(description="Hole center Y coordinate in mm")
+    diameter: float = Field(description="Hole diameter in mm")
+    depth: float | None = Field(
+        default=None, description="Hole depth in mm (None for through hole)"
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the tutorial simple hole input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+
+        Raises:
+            ValueError: Depth must be positive.
+        """
+        if self.diameter <= 0:
+            raise ValueError("diameter must be positive")
+        if self.depth is not None and self.depth <= 0:
+            raise ValueError("depth must be positive")
+
+
+class CheckSketchDefinitionInput(CompatInput):
+    """Input schema for checking sketch definition status.
+
+    Attributes:
+        sketch_name (str | None): Optional sketch name to inspect.
+    """
+
+    sketch_name: str | None = Field(
+        default=None,
+        description="Optional sketch name. If omitted, checks the active or last sketch.",
+    )
+
+
+async def register_sketching_tools(
+    mcp: FastMCP, adapter: SolidWorksAdapter, config: dict[str, Any]
+) -> int:
+    """Register sketching tools with FastMCP.
+
+    Registers comprehensive sketching tools for SolidWorks automation including geometry
+    creation, constraints, dimensions, and pattern operations.
+
+    Args:
+        mcp (FastMCP): The mcp value.
+        adapter (SolidWorksAdapter): Adapter instance used for the operation.
+        config (dict[str, Any]): Configuration values for the operation.
+
+    Returns:
+        int: The computed numeric result.
+
+    Example:
+                        ```python
+                        from solidworks_mcp.tools.sketching import register_sketching_tools
+
+                        tool_count = await register_sketching_tools(mcp, adapter, config)
+                        print(f"Registered {tool_count} sketching tools")
+                        ```
+    """
+    mcp = with_tool_boundary(mcp)
+    tool_count = 0
+
+    @mcp.tool()
+    async def create_sketch(input_data: CreateSketchInput) -> dict[str, Any]:
+        """Create a new sketch on the specified plane.
+
+        Creates a new sketch on a reference plane and enters sketch edit mode. This is the first
+        step for creating any 2D geometry that will be used for 3D features like extrusions,
+        revolves, or sweeps.
+
+        Args:
+            input_data (CreateSketchInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create sketch on top plane for a circular boss
+                            result = await create_sketch({
+                                "plane": "Top"
+                            })
+
+                            if result["status"] == "success":
+                                sketch = result["sketch"]
+                                print(f"Created {sketch['name']} on {sketch['plane']} plane")
+                                # Ready to add geometry with add_line, add_circle, etc.
+                            ```
+
+                        Note:
+                            - Must be called before adding any sketch geometry
+                            - Sketch is automatically selected and ready for geometry addition
+                            - Use exit_sketch() when finished to exit sketch edit mode
+        """
+        input_data = normalize_input(input_data, CreateSketchInput)
+        result = await adapter.create_sketch(input_data.plane)
+
+        require_success(result, context="Failed to create sketch")
+        sketch_name = input_data.sketch_name or (
+            result.data.get("sketch_name")
+            if isinstance(result.data, dict)
+            else result.data
+        )
+        return {
+            "status": "success",
+            "message": f"Created sketch '{sketch_name}' on {input_data.plane} plane",
+            "sketch": {
+                "name": sketch_name,
+                "plane": input_data.plane,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_line(input_data: AddLineInput) -> dict[str, Any]:
+        """Add a line to the current sketch.
+
+        Adds a line segment between two points in the active sketch. Lines are fundamental
+        sketch entities used for creating profiles, construction geometry, and complex shapes.
+
+        Args:
+            input_data (AddLineInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create horizontal base line for rectangular profile
+                            result = await add_line({
+                                "x1": 0, "y1": 0,
+                                "x2": 50, "y2": 0
+                            })
+
+                            if result["status"] == "success":
+                                line = result["line"]
+                                print(f"Created {line['length']:.1f}mm line: {line['id']}")
+                                # Continue adding more geometry or constraints
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Coordinates are relative to sketch origin
+                            - Lines can be constrained after creation
+                            - Useful for creating construction lines with zero length
+        """
+        input_data = normalize_input(input_data, AddLineInput)
+        if hasattr(adapter, "add_sketch_line"):
+            result = await adapter.add_sketch_line(
+                input_data.x1,
+                input_data.y1,
+                input_data.x2,
+                input_data.y2,
+                input_data.construction,
+            )
+        else:
+            result = await adapter.add_line(
+                input_data.x1,  # type: ignore[arg-type]
+                input_data.y1,  # type: ignore[arg-type]
+                input_data.x2,  # type: ignore[arg-type]
+                input_data.y2,  # type: ignore[arg-type]
+            )
+
+        require_success(result, context="Failed to add line")
+        line_id = (
+            result.data.get("entity_id") or result.data.get("id")
+            if isinstance(result.data, dict)
+            else result.data
+        )
+        x1, y1 = input_data.x1 or 0.0, input_data.y1 or 0.0
+        x2, y2 = input_data.x2 or 0.0, input_data.y2 or 0.0
+        return {
+            "status": "success",
+            "message": f"Added line from ({x1}, {y1}) to ({x2}, {y2})",
+            "line": {
+                "id": line_id,
+                "start": {"x": x1, "y": y1},
+                "end": {"x": x2, "y": y2},
+                "construction": input_data.construction,
+                "length": ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_circle(input_data: AddCircleInput) -> dict[str, Any]:
+        """Add a circle to the current sketch.
+
+        Args:
+            input_data (AddCircleInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        input_data = normalize_input(input_data, AddCircleInput)
+        if hasattr(adapter, "add_sketch_circle"):
+            result = await adapter.add_sketch_circle(
+                input_data.center_x,
+                input_data.center_y,
+                input_data.radius,
+                input_data.construction,
+            )
+        else:
+            result = await adapter.add_circle(
+                input_data.center_x, input_data.center_y, input_data.radius
+            )
+
+        require_success(result, context="Failed to add circle")
+        circle_id = (
+            result.data.get("entity_id")
+            if isinstance(result.data, dict)
+            else result.data
+        )
+        return {
+            "status": "success",
+            "message": f"Added circle at ({input_data.center_x}, {input_data.center_y}) with radius {input_data.radius}mm",
+            "circle": {
+                "id": circle_id,
+                "center": {"x": input_data.center_x, "y": input_data.center_y},
+                "radius": input_data.radius,
+                "construction": input_data.construction,
+                "diameter": input_data.radius * 2,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_rectangle(input_data: AddRectangleInput) -> dict[str, Any]:
+        """Add a rectangle to the current sketch.
+
+        Creates a rectangular profile defined by two opposite corner points, automatically
+        generating four connected line segments forming a closed rectangle suitable for
+        extrusion or other 3D operations.
+
+        Args:
+            input_data (AddRectangleInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create 20x10mm rectangular profile
+                            result = await add_rectangle({
+                                "x1": -10.0, "y1": -5.0,
+                                "x2": 10.0, "y2": 5.0
+                            })
+
+                            if result["status"] == "success":
+                                rect = result["rectangle"]
+                                print(f"Created {rect['width']}x{rect['height']}mm rectangle")
+                                # Ready for extrusion or further sketch operations
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Creates four individual line entities with automatic constraints
+                            - Corner coordinates can be in any order (automatically calculated)
+                            - Useful as base profile for extrusions and cuts
+        """
+        input_data = normalize_input(input_data, AddRectangleInput)
+        if hasattr(adapter, "add_sketch_rectangle"):
+            result = await adapter.add_sketch_rectangle(
+                input_data.x1,
+                input_data.y1,
+                input_data.x2,
+                input_data.y2,
+                input_data.construction,
+            )
+        else:
+            result = await adapter.add_rectangle(
+                input_data.x1,  # type: ignore[arg-type]
+                input_data.y1,  # type: ignore[arg-type]
+                input_data.x2,  # type: ignore[arg-type]
+                input_data.y2,  # type: ignore[arg-type]
+            )
+
+        require_success(result, context="Failed to add rectangle")
+        rect_id = (
+            result.data.get("entity_id")
+            if isinstance(result.data, dict)
+            else result.data
+        )
+        rx1, ry1 = input_data.x1 or 0.0, input_data.y1 or 0.0
+        rx2, ry2 = input_data.x2 or 0.0, input_data.y2 or 0.0
+        width = abs(rx2 - rx1)
+        height = abs(ry2 - ry1)
+
+        return {
+            "status": "success",
+            "message": f"Added rectangle from ({rx1}, {ry1}) to ({rx2}, {ry2})",
+            "rectangle": {
+                "id": rect_id,
+                "corner1": {"x": rx1, "y": ry1},
+                "corner2": {"x": rx2, "y": ry2},
+                "construction": input_data.construction,
+                "width": width,
+                "height": height,
+                "area": width * height,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def exit_sketch() -> dict[str, Any]:
+        """Exit sketch editing mode.
+
+        Exits the current sketch editing mode and returns to the 3D modeling environment. This
+        is required after completing sketch geometry before creating 3D features like
+        extrusions, revolves, or sweeps.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Complete sketch workflow
+                            await create_sketch({"plane": "Top"})
+                            await add_circle({"center_x": 0, "center_y": 0, "radius": 5})
+
+                            result = await exit_sketch()
+                            if result["status"] == "success":
+                                print("Sketch completed, ready for 3D operations")
+                                # Now ready for extrude, revolve, etc.
+                            ```
+
+                        Note:
+                            - Must be called after sketch geometry creation
+                            - Required before executing 3D modeling operations
+                            - Automatically validates sketch geometry
+                            - Previous sketch remains selectable for feature creation
+        """
+        result = await adapter.exit_sketch()
+
+        require_success(result, context="Failed to exit sketch")
+        return {
+            "status": "success",
+            "message": "Exited sketch editing mode",
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def check_sketch_fully_defined(
+        input_data: CheckSketchDefinitionInput | None = None,
+    ) -> dict[str, Any]:
+        """Check whether a sketch is fully defined.
+
+        Args:
+            input_data (CheckSketchDefinitionInput | None): Optional sketch selector.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        normalized = normalize_input(
+            input_data or {},
+            CheckSketchDefinitionInput,
+        )
+        result = await adapter.check_sketch_fully_defined(normalized.sketch_name)
+
+        require_success(result, context="Failed to inspect sketch definition")
+
+        payload = result.data or {}
+        state = payload.get("definition_state", "unknown")
+        return {
+            "status": "success",
+            "message": f"Sketch definition state: {state}",
+            "sketch": payload,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_arc(input_data: AddArcInput) -> dict[str, Any]:
+        """Add an arc to the current sketch.
+
+        Creates a circular arc defined by center point, start point, and end point. Arcs are
+        essential for creating rounded corners, curved transitions, and complex curved profiles
+        in mechanical designs.
+
+        Args:
+            input_data (AddArcInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create 90-degree arc for rounded corner (10mm radius)
+                            result = await add_arc({
+                                "center_x": 10.0, "center_y": 10.0,
+                                "start_x": 20.0, "start_y": 10.0,  # 3 o'clock
+                                "end_x": 10.0, "end_y": 20.0       # 12 o'clock
+                            })
+
+                            if result["status"] == "success":
+                                arc = result["arc"]
+                                print(f"Created arc: {arc['id']}")
+                                # Perfect for filleting corners automatically
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Start and end points must be equidistant from center
+                            - Arc direction follows counter-clockwise convention
+                            - Commonly used for fillets and rounded profiles
+        """
+        input_data = normalize_input(input_data, AddArcInput)
+        result = await adapter.add_arc(
+            input_data.center_x,
+            input_data.center_y,
+            input_data.start_x,
+            input_data.start_y,
+            input_data.end_x,
+            input_data.end_y,
+        )
+
+        require_success(result, context="Failed to add arc")
+        arc_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added arc centered at ({input_data.center_x}, {input_data.center_y})",
+            "arc": {
+                "id": arc_id,
+                "center": {"x": input_data.center_x, "y": input_data.center_y},
+                "start_point": {
+                    "x": input_data.start_x,
+                    "y": input_data.start_y,
+                },
+                "end_point": {"x": input_data.end_x, "y": input_data.end_y},
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_spline(input_data: AddSplineInput) -> dict[str, Any]:
+        """Add a spline curve to the current sketch.
+
+        Creates a smooth, free-form spline curve that passes through or near the specified
+        control points. Splines are ideal for creating organic shapes, complex profiles, and
+        smooth transitions in industrial design.
+
+        Args:
+            input_data (AddSplineInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create smooth aerodynamic profile
+                            result = await add_spline({
+                                "points": [
+                                    {"x": 0.0, "y": 0.0},     # Leading edge
+                                    {"x": 25.0, "y": 8.0},    # Upper surface
+                                    {"x": 75.0, "y": 5.0},    # Mid-chord
+                                    {"x": 100.0, "y": 2.0},   # Trailing edge
+                                    {"x": 100.0, "y": 0.0}    # Trailing point
+                                ]
+                            })
+
+                            if result["status"] == "success":
+                                spline = result["spline"]
+                                print(f"Created smooth profile with {spline['point_count']} points")
+                                # Perfect for aerodynamic and ergonomic shapes
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - More control points create smoother, more complex curves
+                            - Spline weights and tangencies can be modified post-creation
+                            - Essential for automotive and aerospace profile design
+        """
+        result = await adapter.add_spline(input_data.points)
+
+        require_success(result, context="Failed to add spline")
+        spline_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added spline with {len(input_data.points)} control points",
+            "spline": {
+                "id": spline_id,
+                "control_points": input_data.points,
+                "point_count": len(input_data.points),
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_centerline(input_data: AddLineInput) -> dict[str, Any]:
+        """Add a centerline to the current sketch.
+
+        Creates a construction/reference line that serves as a centerline for symmetrical
+        features, revolution axes, or construction geometry. Centerlines are non-geometric
+        entities used for reference only.
+
+        Args:
+            input_data (AddLineInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create vertical centerline for symmetric feature
+                            result = await add_centerline({
+                                "x1": 0.0, "y1": -20.0,
+                                "x2": 0.0, "y2": 20.0
+                            })
+
+                            if result["status"] == "success":
+                                centerline = result["centerline"]
+                                print(f"Created {centerline['type']} centerline: {centerline['id']}")
+                                # Use for mirror operations or revolution axis
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Centerlines don't contribute to profile geometry
+                            - Essential for symmetrical design and mirroring operations
+                            - Commonly used as revolution axes for turned parts
+        """
+        input_data = normalize_input(input_data, AddLineInput)
+
+        result = await adapter.add_centerline(
+            input_data.x1,  # type: ignore[arg-type]
+            input_data.y1,  # type: ignore[arg-type]
+            input_data.x2,  # type: ignore[arg-type]
+            input_data.y2,  # type: ignore[arg-type]
+        )
+
+        require_success(result, context="Failed to add centerline")
+        centerline_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added centerline from ({input_data.x1}, {input_data.y1}) to ({input_data.x2}, {input_data.y2})",
+            "centerline": {
+                "id": centerline_id,
+                "start_point": {"x": input_data.x1, "y": input_data.y1},
+                "end_point": {"x": input_data.x2, "y": input_data.y2},
+                "type": "construction",
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_polygon(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Add a regular polygon to the current sketch.
+
+        Creates a regular polygon with specified number of sides, center point, and
+        circumscribed radius. Polygons are useful for creating hexagonal nuts, octagonal
+        features, and other multi-sided geometric shapes.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create M6 hexagonal nut profile (11mm across flats)
+                            result = await add_polygon({
+                                "center_x": 0.0, "center_y": 0.0,
+                                "radius": 6.35,  # 11mm across flats
+                                "sides": 6
+                            })
+
+                            if result["status"] == "success":
+                                polygon = result["polygon"]
+                                print(f"Created {polygon['sides']}-sided polygon: {polygon['id']}")
+                                # Perfect for nut profiles and gear blanks
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Radius is circumscribed (vertex-to-center distance)
+                            - Common sides: 6 (hex), 8 (octagon), 12 (dodecagon)
+                            - Ideal for fastener profiles and gear geometries
+        """
+        center_x = input_data.get("center_x", 0.0)
+        center_y = input_data.get("center_y", 0.0)
+        radius = input_data.get("radius", 10.0)
+        sides = input_data.get("sides", 6)
+
+        result = await adapter.add_polygon(center_x, center_y, radius, sides)
+
+        require_success(result, context="Failed to add polygon")
+        polygon_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added {sides}-sided polygon at ({center_x}, {center_y}) with radius {radius}mm",
+            "polygon": {
+                "id": polygon_id,
+                "center": {"x": center_x, "y": center_y},
+                "radius": radius,
+                "sides": sides,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_ellipse(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Add an ellipse to the current sketch.
+
+        Creates an elliptical entity with specified center and major/minor axes. Ellipses are
+        useful for creating oval holes, ergonomic profiles, and complex curved features in
+        mechanical and industrial design.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create oval slot for ergonomic handle
+                            result = await add_ellipse({
+                                "center_x": 0.0, "center_y": 0.0,
+                                "major_axis": 30.0,  # 30mm wide
+                                "minor_axis": 15.0   # 15mm tall
+                            })
+
+                            if result["status"] == "success":
+                                ellipse = result["ellipse"]
+                                print(f"Created {ellipse['major_axis']}x{ellipse['minor_axis']}mm ellipse")
+                                # Perfect for ergonomic cutouts and slots
+                            ```
+
+                        Note:
+                            - Requires an active sketch (use create_sketch first)
+                            - Major axis should be larger than minor axis
+                            - Useful for ergonomic designs and aerodynamic profiles
+                            - Can be dimensionally constrained after creation
+        """
+        center_x = input_data.get("center_x", 0.0)
+        center_y = input_data.get("center_y", 0.0)
+        major_axis = input_data.get("major_axis", 20.0)
+        minor_axis = input_data.get("minor_axis", 10.0)
+
+        result = await adapter.add_ellipse(center_x, center_y, major_axis, minor_axis)
+
+        require_success(result, context="Failed to add ellipse")
+        ellipse_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added ellipse at ({center_x}, {center_y}) with axes {major_axis}x{minor_axis}mm",
+            "ellipse": {
+                "id": ellipse_id,
+                "center": {"x": center_x, "y": center_y},
+                "major_axis": major_axis,
+                "minor_axis": minor_axis,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_sketch_constraint(input_data: AddRelationInput) -> dict[str, Any]:
+        """Add a geometric constraint/relation between sketch entities.
+
+        Creates geometric relationships between sketch entities such as parallel, perpendicular,
+        tangent, coincident, etc. Essential for creating fully defined, parametric sketches that
+        maintain design intent.
+
+        Args:
+            input_data (AddRelationInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Make two lines perpendicular for right-angle corner
+                            result = await add_sketch_constraint({
+                                "entity1": "Line1",
+                                "entity2": "Line2",
+                                "relation_type": "perpendicular"
+                            })
+
+                            if result["status"] == "success":
+                                constraint = result["constraint"]
+                                print(f"Applied {constraint['type']} constraint")
+                                # Sketch now maintains 90-degree relationship
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing entities
+                            - Some constraints require only one entity (horizontal, vertical)
+                            - Essential for parametric design and maintaining intent
+                            - Over-constraining can cause sketch to fail
+        """
+        input_data = normalize_input(input_data, AddRelationInput)
+        result = await adapter.add_sketch_constraint(
+            input_data.entity1,
+            input_data.entity2,
+            input_data.relation_type,
+            input_data.entity3,
+        )
+
+        require_success(result, context="Failed to add constraint")
+        constraint_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added {input_data.relation_type} constraint between {input_data.entity1} and {input_data.entity2}",
+            "constraint": {
+                "id": constraint_id,
+                "type": input_data.relation_type,
+                "entity1": input_data.entity1,
+                "entity2": input_data.entity2,
+                "entity3": input_data.entity3,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_sketch_dimension(input_data: AddDimensionInput) -> dict[str, Any]:
+        """Add a dimension to sketch entities.
+
+        Creates dimensional constraints that control the size of sketch entities. Dimensions are
+        essential for creating precise, parametric designs that can be easily modified and
+        maintain manufacturing tolerances.
+
+        In live SolidWorks automation, sketch dimensions can otherwise trigger the interactive
+        ``Modify`` approval dialog. The adapter suppresses the relevant sketch-input preferences
+        for the automation session and uses the dedicated radial/diameter APIs for circles and
+        arcs so this tool remains non-interactive.
+
+        Args:
+            input_data (AddDimensionInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Dimension circle for precise 6mm diameter hole
+                            result = await add_sketch_dimension({
+                                "entity1": "Circle1",
+                                "entity2": None,
+                                "dimension_type": "diameter",
+                                "value": 6.0
+                            })
+
+                            if result["status"] == "success":
+                                dim = result["dimension"]
+                                print(f"Applied {dim['value']}mm {dim['type']} dimension")
+                                # Circle now precisely controlled for manufacturing
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing entities
+                            - Dimensions drive entity size and control parametric behavior
+                            - Over-dimensioning can cause constraint conflicts
+                            - Essential for manufacturing precision and design intent
+                            - Radial and diameter dimensions use SolidWorks-specific APIs to avoid
+                              falling back to the interactive Smart Dimension approval flow
+        """
+        input_data = normalize_input(input_data, AddDimensionInput)
+        result = await adapter.add_sketch_dimension(
+            input_data.entity1,
+            input_data.entity2,
+            input_data.dimension_type,
+            input_data.value,
+        )
+
+        require_success(result, context="Failed to add dimension")
+        dimension_id = result.data
+        return {
+            "status": "success",
+            "message": f"Added {input_data.dimension_type} dimension of {input_data.value}mm to {input_data.entity1}",
+            "dimension": {
+                "id": dimension_id,
+                "type": input_data.dimension_type,
+                "value": input_data.value,
+                "entity1": input_data.entity1,
+                "entity2": input_data.entity2,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def sketch_linear_pattern(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Create a linear pattern of sketch entities.
+
+        Generates a linear array of selected sketch entities in specified direction(s) with
+        defined spacing and count. Essential for creating hole patterns, vent grilles, and
+        repetitive geometric features.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create 5x1 hole pattern for ventilation grille
+                            result = await sketch_linear_pattern({
+                                "entities": ["Circle1"],
+                                "direction_x": 1.0, "direction_y": 0.0,  # Horizontal
+                                "spacing": 15.0,  # 15mm apart
+                                "count": 5
+                            })
+
+                            if result["status"] == "success":
+                                pattern = result["pattern"]
+                                print(f"Created {pattern['count']} instances, {pattern['spacing']}mm apart")
+                                # Perfect for mounting hole patterns
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing entities
+                            - Direction vector determines pattern orientation
+                            - Original entities remain as pattern seed geometry
+                            - Commonly used for fastener and ventilation hole patterns
+        """
+        entities = input_data.get("entities", [])
+        direction_x = input_data.get("direction_x", 1.0)
+        direction_y = input_data.get("direction_y", 0.0)
+        spacing = input_data.get("spacing", 10.0)
+        count = input_data.get("count", 3)
+
+        result = await adapter.sketch_linear_pattern(
+            entities, direction_x, direction_y, spacing, count
+        )
+
+        require_success(result, context="Failed to create linear pattern")
+        pattern_id = result.data
+        return {
+            "status": "success",
+            "message": f"Created linear pattern with {count} instances, spacing {spacing}mm",
+            "pattern": {
+                "id": pattern_id,
+                "type": "linear",
+                "entities": entities,
+                "count": count,
+                "spacing": spacing,
+                "direction": {"x": direction_x, "y": direction_y},
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def sketch_circular_pattern(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Create a circular pattern of sketch entities around the sketch origin.
+
+        Generates a circular array of selected sketch entities. The
+        rotation axis is always the **sketch origin** — SOLIDWORKS'
+        ``CreateCircularSketchStepAndRepeat`` does not expose a
+        pattern-centre parameter. Position the seed entity at the
+        desired radius from the origin; the pattern derives its radius
+        from the seed's centre.
+
+        Essential for creating bolt circles, gear teeth, and other
+        radially symmetric features around the sketch origin.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create 6-bolt circle pattern (seed circle at radius 50 mm on +X)
+                            result = await sketch_circular_pattern({
+                                "entities": ["Circle1"],
+                                "angle": 360.0,  # Full circle
+                                "count": 6       # 6 bolt holes
+                            })
+
+                            if result["status"] == "success":
+                                pattern = result["pattern"]
+                                print(f"Created {pattern['count']}-bolt circle pattern")
+                                # Perfect for flange and wheel bolt patterns
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing entities
+                            - Rotation axis is always the sketch origin (0, 0)
+                            - Angle < 360° creates partial circular patterns
+                            - Essential for mechanical fastener patterns and gear design
+        """
+        entities = input_data.get("entities", [])
+        angle = input_data.get("angle", 360.0)
+        count = input_data.get("count", 6)
+
+        result = await adapter.sketch_circular_pattern(entities, angle, count)
+
+        require_success(result, context="Failed to create circular pattern")
+        pattern_id = result.data
+        return {
+            "status": "success",
+            "message": (
+                f"Created circular pattern with {count} instances "
+                "around the sketch origin"
+            ),
+            "pattern": {
+                "id": pattern_id,
+                "type": "circular",
+                "entities": entities,
+                "count": count,
+                "center": {"x": 0.0, "y": 0.0},
+                "angle": angle,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def sketch_mirror(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Mirror sketch entities about a centerline.
+
+        Creates mirrored copies of selected sketch entities about a reference centerline,
+        maintaining symmetrical design relationships. Essential for creating symmetric parts and
+        reducing modeling time.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Mirror half of a symmetric bracket about centerline
+                            result = await sketch_mirror({
+                                "entities": ["Line1", "Arc1", "Circle1"],
+                                "mirror_line": "Centerline1"
+                            })
+
+                            if result["status"] == "success":
+                                mirror = result["mirror"]
+                                print(f"Mirrored {len(mirror['entities'])} entities")
+                                # Creates perfectly symmetric design automatically
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing entities and centerline
+                            - Mirror line must be a construction/centerline entity
+                            - Creates dependent copies that update with original geometry
+                            - Essential for symmetric mechanical parts and assemblies
+        """
+        entities = input_data.get("entities", [])
+        mirror_line = input_data.get("mirror_line", "")
+
+        result = await adapter.sketch_mirror(entities, mirror_line)
+
+        require_success(result, context="Failed to mirror entities")
+        mirror_id = result.data
+        return {
+            "status": "success",
+            "message": f"Mirrored {len(entities)} entities about {mirror_line}",
+            "mirror": {
+                "id": mirror_id,
+                "entities": entities,
+                "mirror_line": mirror_line,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def sketch_offset(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Create an offset of sketch entities.
+
+        Generates offset copies of selected sketch entities at a specified distance, maintaining
+        the original entity shape while creating parallel geometry. Essential for wall
+        thickness, machining allowances, and clearance features.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create wall thickness by offsetting outer profile inward
+                            result = await sketch_offset({
+                                "entities": ["Rectangle1"],
+                                "offset_distance": 2.0,     # 2mm wall thickness
+                                "reverse_direction": True   # Inward offset
+                            })
+
+                            if result["status"] == "success":
+                                offset = result["offset"]
+                                print(f"Created {offset['distance']}mm {offset['direction']} offset")
+                                # Perfect for creating hollow sections and wall features
+                            ```
+
+                        Note:
+                            - Requires an active sketch with existing closed profiles
+                            - Offset distance determines wall thickness or clearance
+                            - Direction affects whether result is larger or smaller
+                            - Essential for sheet metal design and machining operations
+        """
+        entities = input_data.get("entities", [])
+        offset_distance = input_data.get("offset_distance", 5.0)
+        reverse_direction = input_data.get("reverse_direction", False)
+
+        result = await adapter.sketch_offset(
+            entities, offset_distance, reverse_direction
+        )
+
+        require_success(result, context="Failed to create offset")
+        offset_id = result.data
+        direction = "outward" if not reverse_direction else "inward"
+        return {
+            "status": "success",
+            "message": f"Created offset of {len(entities)} entities by {offset_distance}mm ({direction})",
+            "offset": {
+                "id": offset_id,
+                "entities": entities,
+                "distance": offset_distance,
+                "direction": direction,
+            },
+            "execution_time": result.execution_time,
+        }
+
+    # Additional sketch tools can be added here in the future:
+    # - add_arc (3-point arc, center-point arc)
+    # - add_spline (free-form curves)
+    # - add_dimension (dimensional constraints)
+    # - add_relation (geometric constraints like parallel, perpendicular)
+    # - add_pattern (circular, linear patterns)
+    # - trim_entities (trim overlapping geometry)
+    # - mirror_entities (mirror sketch geometry)
+
+    @mcp.tool()
+    async def sketch_tutorial_simple_hole() -> dict[str, Any]:
+        """Tutorial: Create a simple circular hole sketch.
+
+        Demonstrates complete workflow for creating a basic hole sketch that can be used for
+        through-holes, counterbores, or other circular features. This tutorial shows the
+        fundamental sketch-to-feature process.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Learn basic sketching workflow
+                            result = await sketch_tutorial_simple_hole()
+
+                            if result["status"] == "success":
+                                print("Tutorial completed successfully!")
+                                print("Steps performed:")
+                                for step in result["steps"]:
+                                    print(f"  - {step}")
+                                print(f"Next: {result['next_steps']}")
+                            ```
+
+                        Workflow:
+                            1. Creates sketch on Top plane
+                            2. Adds 2.5mm radius circle at origin (5mm diameter hole)
+                            3. Exits sketch editing mode
+                            4. Returns sketch ready for extrusion or cutting operations
+
+                        Note:
+                            - Demonstrates complete sketch creation workflow
+                            - Creates standard 5mm diameter hole geometry
+                            - Result is ready for negative extrusion to create hole
+                            - Perfect starting point for learning SolidWorks automation
+        """
+        steps_completed = []
+
+        # Step 1: Create sketch
+        sketch_result = await adapter.create_sketch("Top")
+        require_success(sketch_result, context="Failed to create sketch")
+        steps_completed.append(f"Created sketch: {sketch_result.data}")
+
+        # Step 2: Add circle
+        circle_result = await adapter.add_circle(0, 0, 2.5)
+        require_success(circle_result, context="Failed to add circle")
+        steps_completed.append(f"Added 5mm diameter circle: {circle_result.data}")
+
+        # Step 3: Exit sketch
+        exit_result = await adapter.exit_sketch()
+        require_success(exit_result, context="Failed to exit sketch")
+        steps_completed.append("Exited sketch")
+
+        return {
+            "status": "success",
+            "message": "Tutorial completed: Simple hole sketch created",
+            "steps_completed": steps_completed,
+            "next_step": "Use create_extrusion with negative depth to create the hole",
+            "suggested_extrusion": {
+                "depth": -10,  # Negative for cut
+                "reverse_direction": False,
+            },
+        }
+
+    @mcp.tool()
+    async def tutorial_simple_hole(
+        input_data: TutorialSimpleHoleInput,
+    ) -> dict[str, Any]:
+        """Create a simple hole as a guided tutorial workflow.
+
+        Builds a sketch circle on the selected plane, exits the sketch, and creates a cut
+        feature using the supplied diameter and depth. Useful as an end-to-end example of a
+        basic subtractive feature.
+
+        Args:
+            input_data (TutorialSimpleHoleInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        steps: list[dict[str, Any]] = []
+
+        sketch_result = await adapter.create_sketch(input_data.plane)
+        require_success(sketch_result, context="Failed to create sketch")
+        steps.append({"step": "Create sketch", "status": "success"})
+
+        circle_result = await adapter.add_sketch_circle(
+            input_data.center_x,
+            input_data.center_y,
+            input_data.diameter / 2,
+            False,
+        )
+        require_success(circle_result, context="Failed to add circle")
+        steps.append({"step": "Add circle", "status": "success"})
+
+        exit_result = await adapter.exit_sketch()
+        require_success(exit_result, context="Failed to exit sketch")
+        steps.append({"step": "Exit sketch", "status": "success"})
+
+        cut_depth = (
+            input_data.depth if input_data.depth is not None else input_data.diameter
+        )
+        cut_result = await adapter.create_cut("HoleSketch", cut_depth)
+        require_success(cut_result, context="Failed to create cut extrude")
+        steps.append({"step": "Create cut extrude", "status": "success"})
+
+        return {
+            "status": "success",
+            "message": "Completed simple hole tutorial",
+            "tutorial": {
+                "plane": input_data.plane,
+                "diameter": input_data.diameter,
+                "depth": input_data.depth,
+                "steps": steps,
+            },
+        }
+
+    tool_count = 6  # Legacy count expected by tests
+    return tool_count