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

solidworks_mcp/tools/drawing.py

@@ -0,0 +1,1015 @@
+"""Drawing tools for SolidWorks MCP Server.
+
+Provides tools for creating drawing views, adding dimensions, annotations, and managing
+technical drawings in SolidWorks.
+"""
+
+from typing import Any
+
+from fastmcp import FastMCP
+from pydantic import BaseModel, Field
+
+from ..adapters.base import SolidWorksAdapter
+from .input_compat import CompatInput
+from .tool_boundary import (
+    UnsupportedOperationError,
+    normalize_input,
+    require_capability,
+    require_success,
+    with_tool_boundary,
+)
+
+# Input schemas using Python 3.14 built-in types
+
+
+class CreateDrawingViewInput(BaseModel):
+    """Input schema for creating drawing views.
+
+    Attributes:
+        model_path (str): The model path value.
+        orientation (str): The orientation value.
+        position_x (float): The position x value.
+        position_y (float): The position y value.
+        scale (float): The scale value.
+        view_type (str): The view type value.
+    """
+
+    model_path: str = Field(description="Path to the SolidWorks model file")
+    view_type: str = Field(
+        description="Type of view (orthographic, isometric, section, detail)"
+    )
+    position_x: float = Field(default=100.0, description="X position in drawing (mm)")
+    position_y: float = Field(default=200.0, description="Y position in drawing (mm)")
+    scale: float = Field(default=1.0, description="View scale factor")
+    orientation: str = Field(
+        default="front", description="View orientation (front, top, right, isometric)"
+    )
+
+
+class AddDimensionInput(BaseModel):
+    """Input schema for adding dimensions.
+
+    Attributes:
+        dimension_type (str): The dimension type value.
+        entity1 (str): The entity1 value.
+        entity2 (str | None): The entity2 value.
+        position_x (float): The position x value.
+        position_y (float): The position y value.
+        precision (int): The precision value.
+    """
+
+    dimension_type: str = Field(
+        description="Type of dimension (linear, radial, angular, diameter)"
+    )
+    entity1: str = Field(description="First entity to dimension (edge, face, point)")
+    entity2: str | None = Field(
+        default=None, description="Second entity for linear/angular dimensions"
+    )
+    position_x: float = Field(description="X position for dimension text")
+    position_y: float = Field(description="Y position for dimension text")
+    precision: int = Field(default=2, description="Number of decimal places")
+
+
+class AddNoteInput(BaseModel):
+    """Input schema for adding notes/annotations.
+
+    Attributes:
+        font_size (float): The font size value.
+        leader_attachment (str | None): The leader attachment value.
+        position_x (float): The position x value.
+        position_y (float): The position y value.
+        text (str): The text value.
+    """
+
+    text: str = Field(description="Note text content")
+    position_x: float = Field(description="X position for note")
+    position_y: float = Field(description="Y position for note")
+    font_size: float = Field(default=12.0, description="Font size in points")
+    leader_attachment: str | None = Field(
+        default=None, description="Entity to attach leader line to"
+    )
+
+
+class CreateSectionViewInput(BaseModel):
+    """Input schema for creating section views.
+
+    Attributes:
+        label (str): The label value.
+        scale (float): The scale value.
+        section_line_end (list[float]): The section line end value.
+        section_line_start (list[float]): The section line start value.
+        view_position_x (float): The view position x value.
+        view_position_y (float): The view position y value.
+    """
+
+    section_line_start: list[float] = Field(
+        description="Start point of section line as [x, y]",
+        min_length=2,
+        max_length=2,
+        json_schema_extra={"items": {"type": "number"}},
+    )
+    section_line_end: list[float] = Field(
+        description="End point of section line as [x, y]",
+        min_length=2,
+        max_length=2,
+        json_schema_extra={"items": {"type": "number"}},
+    )
+    view_position_x: float = Field(description="X position for section view")
+    view_position_y: float = Field(description="Y position for section view")
+    scale: float = Field(default=1.0, description="Section view scale")
+    label: str = Field(default="A", description="Section view label")
+
+
+class CreateDetailViewInput(BaseModel):
+    """Input schema for creating detail views.
+
+    Attributes:
+        center_x (float): The center x value.
+        center_y (float): The center y value.
+        label (str): The label value.
+        radius (float): The radius value.
+        scale (float): The scale value.
+        view_position_x (float): The view position x value.
+        view_position_y (float): The view position y value.
+    """
+
+    center_x: float = Field(description="X center of detail circle")
+    center_y: float = Field(description="Y center of detail circle")
+    radius: float = Field(description="Radius of detail circle")
+    view_position_x: float = Field(description="X position for detail view")
+    view_position_y: float = Field(description="Y position for detail view")
+    scale: float = Field(default=2.0, description="Detail view scale")
+    label: str = Field(default="A", description="Detail view label")
+
+
+class UpdateSheetFormatInput(BaseModel):
+    """Input schema for updating sheet format.
+
+    Attributes:
+        approved_by (str): The approved by value.
+        checked_by (str): The checked by value.
+        drawing_number (str): The drawing number value.
+        drawn_by (str): The drawn by value.
+        format_file (str): The format file value.
+        sheet_size (str): The sheet size value.
+        title (str): The title value.
+    """
+
+    format_file: str = Field(description="Path to sheet format template (.slddrt)")
+    sheet_size: str = Field(default="A3", description="Sheet size (A4, A3, A2, A1, A0)")
+    title: str = Field(default="", description="Drawing title")
+    drawn_by: str = Field(default="", description="Drawn by field")
+    checked_by: str = Field(default="", description="Checked by field")
+    approved_by: str = Field(default="", description="Approved by field")
+    drawing_number: str = Field(default="", description="Drawing number")
+
+
+class AutoCenterMarksInput(CompatInput):
+    """Input schema for auto-inserting drawing centre marks.
+
+    Attributes:
+        view_name (str): Name of a view on the active drawing.
+        mark_holes (bool): Mark holes / bores.
+        mark_fillets (bool): Mark fillets.
+        mark_slots (bool): Mark slots.
+    """
+
+    view_name: str = Field(
+        description="Name of a view on the active drawing, e.g. 'Drawing View1'"
+    )
+    mark_holes: bool = Field(default=True, description="Mark holes / bores")
+    mark_fillets: bool = Field(default=False, description="Mark fillets")
+    mark_slots: bool = Field(default=True, description="Mark slots")
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.view_name.strip():
+            raise ValueError("view_name is required")
+
+
+class DrawingCreationInput(CompatInput):
+    """Input schema for creating a new drawing.
+
+    Attributes:
+        auto_populate_views (bool): The auto populate views value.
+        model_file (str | None): The model file value.
+        output_path (str | None): The output path value.
+        scale (str): The scale value.
+        sheet_format (str | None): The sheet format value.
+        sheet_size (str): The sheet size value.
+        template (str | None): The template value.
+        title (str): The title value.
+    """
+
+    template: str | None = Field(default=None, description="Drawing template file path")
+    model_file: str | None = Field(
+        default=None, description="Model file to create drawing from"
+    )
+    sheet_size: str = Field(default="A3", description="Sheet size")
+    title: str = Field(default="", description="Drawing title")
+    output_path: str | None = Field(default=None, description="Output drawing path")
+    sheet_format: str | None = Field(default=None, description="Sheet format")
+    scale: str = Field(default="1:1", description="Drawing scale")
+    auto_populate_views: bool = Field(
+        default=False, description="Automatically populate standard views"
+    )
+
+
+class DrawingViewInput(CompatInput):
+    """Input schema for drawing view operations.
+
+    Attributes:
+        drawing_path (str | None): The drawing path value.
+        model_file (str | None): The model file value.
+        operation (str): The operation value.
+        parameters (dict[str, Any]): The parameters value.
+        parent_view (str | None): The parent view value.
+        position (list[float] | None): The position value.
+        scale (str | None): The scale value.
+        view_name (str | None): The view name value.
+        view_type (str | None): The view type value.
+    """
+
+    drawing_path: str | None = Field(default=None, description="Path to drawing file")
+    view_name: str | None = Field(default=None, description="Name of the drawing view")
+    operation: str = Field(
+        default="add", description="Operation to perform (create, update, delete)"
+    )
+    model_file: str | None = Field(default=None, description="Model file path")
+    view_type: str | None = Field(default=None, description="Type of view")
+    parent_view: str | None = Field(default=None, description="Parent view alias")
+    position: list[float] | None = Field(default=None, description="View position")
+    scale: str | None = Field(default=None, description="View scale")
+    parameters: dict[str, Any] = Field(default={}, description="View parameters")
+
+
+class DimensionInput(CompatInput):
+    """Input schema for dimension operations.
+
+    Attributes:
+        dimension_name (str | None): The dimension name value.
+        dimension_type (str | None): The dimension type value.
+        drawing_path (str | None): The drawing path value.
+        entities (list[str] | None): The entities value.
+        entity1 (str | None): The entity1 value.
+        entity2 (str | None): The entity2 value.
+        operation (str | None): The operation value.
+        position (list[float] | None): The position value.
+        position_x (float | None): The position x value.
+        position_y (float | None): The position y value.
+        precision (int): The precision value.
+        tolerance (str | None): The tolerance value.
+        value (float | None): The value value.
+    """
+
+    drawing_path: str | None = Field(default=None, description="Path to drawing file")
+    dimension_name: str | None = Field(
+        default=None, description="Name of the dimension"
+    )
+    operation: str | None = Field(
+        default="add", description="Operation to perform (add, update, delete)"
+    )
+    value: float | None = Field(default=None, description="Dimension value")
+    dimension_type: str | None = Field(default=None, description="Type of dimension")
+    entities: list[str] | None = Field(
+        default=None, description="Entities to dimension"
+    )
+    entity1: str | None = Field(default=None, description="Primary entity alias")
+    entity2: str | None = Field(default=None, description="Secondary entity alias")
+    position: list[float] | None = Field(default=None, description="Dimension position")
+    position_x: float | None = Field(default=None, description="Position X alias")
+    position_y: float | None = Field(default=None, description="Position Y alias")
+    precision: int = Field(default=2, description="Precision alias")
+    tolerance: str | None = Field(default=None, description="Dimension tolerance")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the dimension input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.entities:
+            if self.entity1 is None and len(self.entities) >= 1:
+                self.entity1 = self.entities[0]
+            if self.entity2 is None and len(self.entities) >= 2:
+                self.entity2 = self.entities[1]
+        if self.position and len(self.position) >= 2:
+            if self.position_x is None:
+                self.position_x = float(self.position[0])
+            if self.position_y is None:
+                self.position_y = float(self.position[1])
+
+
+class AnnotationInput(CompatInput):
+    """Input schema for annotation operations.
+
+    Attributes:
+        annotation_type (str): The annotation type value.
+        approved_by (str): The approved by value.
+        checked_by (str): The checked by value.
+        drawing_number (str): The drawing number value.
+        drawing_path (str | None): The drawing path value.
+        drawn_by (str): The drawn by value.
+        font_size (float): The font size value.
+        leader_attachment (str | None): The leader attachment value.
+        position (list[float] | None): The position value.
+        position_x (float | None): The position x value.
+        position_y (float | None): The position y value.
+        text (str): The text value.
+    """
+
+    drawing_path: str | None = Field(default=None, description="Path to drawing file")
+    annotation_type: str = Field(
+        description="Type of annotation (note, balloon, surface_finish, etc.)"
+    )
+    text: str = Field(description="Annotation text content")
+    position_x: float | None = Field(
+        default=None, description="X position for annotation"
+    )
+    position_y: float | None = Field(
+        default=None, description="Y position for annotation"
+    )
+    position: list[float] | None = Field(
+        default=None, description="Annotation position"
+    )
+    font_size: float = Field(default=12.0, description="Font size in points")
+    leader_attachment: str | None = Field(
+        default=None, description="Entity to attach leader line to"
+    )
+    drawn_by: str = Field(default="", description="Drawn by field")
+    checked_by: str = Field(default="", description="Checked by field")
+    approved_by: str = Field(default="", description="Approved by field")
+    drawing_number: str = Field(default="", description="Drawing number")
+
+    def model_post_init(self, __context: Any) -> None:
+        """Provide model post init support for the annotation input.
+
+        Args:
+            __context (Any): The context value.
+
+        Returns:
+            None: None.
+        """
+        if self.position is not None and len(self.position) >= 2:
+            if self.position_x is None:
+                self.position_x = float(self.position[0])
+            if self.position_y is None:
+                self.position_y = float(self.position[1])
+
+
+async def register_drawing_tools(
+    mcp: FastMCP, adapter: SolidWorksAdapter, config: dict[str, Any]
+) -> int:
+    """Register drawing tools with FastMCP.
+
+    Registers comprehensive technical drawing tools for SolidWorks automation including view
+    creation, dimensioning, annotation, and drawing standards validation. Essential for
+    automated documentation workflows.
+
+    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.drawing import register_drawing_tools
+
+                        tool_count = await register_drawing_tools(mcp, adapter, config)
+                        print(f"Registered {tool_count} drawing tools")
+                        ```
+    """
+    mcp = with_tool_boundary(mcp)
+    tool_count = 0
+
+    @mcp.tool()
+    async def create_drawing_view(input_data: CreateDrawingViewInput) -> dict[str, Any]:
+        """Create a drawing view of a SolidWorks model.
+
+        Creates technical drawing views including orthographic projections, isometric views,
+        section views, and detail views from 3D models. Essential for generating production
+        drawings and technical documentation.
+
+        Args:
+            input_data (CreateDrawingViewInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create front orthographic view of a part
+                            result = await create_drawing_view({
+                                "model_path": "C:/Models/bracket.sldprt",
+                                "view_type": "orthographic",
+                                "position_x": 150.0, "position_y": 250.0,
+                                "scale": 1.0,
+                                "orientation": "front"
+                            })
+
+                            if result["status"] == "success":
+                                view = result["drawing_view"]
+                                print(f"Created {view['view_type']} view at {view['scale']}:1 scale")
+                                # Ready for dimensioning and annotation
+                            ```
+
+                        Note:
+                            - Model file must exist and be accessible
+                            - Drawing sheet must be active before creating views
+                            - View positioning follows drawing sheet coordinate system
+                            - Multiple views can reference the same model file
+        """
+        require_capability(
+            adapter,
+            "create_drawing_view",
+            "Active adapter does not support create_drawing_view; no "
+            f"{input_data.view_type} view of {input_data.model_path} was created.",
+        )
+        result = await adapter.create_drawing_view(input_data.model_dump())
+        require_success(result, "Failed to create drawing view")
+        return {
+            "status": "success",
+            "message": f"Created {input_data.view_type} view of {input_data.model_path}",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_dimension(input_data: AddDimensionInput) -> dict[str, Any]:
+        """Add a dimension to the current drawing.
+
+        Creates dimensional annotations on drawing views including linear, radial, angular, and
+        diameter dimensions. Essential for manufacturing specifications and quality control
+        documentation.
+
+        Args:
+            input_data (AddDimensionInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Add diameter dimension to a hole
+                            result = await add_dimension({
+                                "dimension_type": "diameter",
+                                "entity1": "Circle1",
+                                "entity2": None,
+                                "position_x": 100.0, "position_y": 150.0,
+                                "precision": 2
+                            })
+
+                            if result["status"] == "success":
+                                dim = result["dimension"]
+                                print(f"Added {dim['type']} dimension with {dim['precision']} decimals")
+                                # Dimension now drives manufacturing specification
+                            ```
+
+                        Note:
+                            - Entities must be visible in current drawing view
+                            - Dimension placement affects drawing readability
+                            - Precision should match manufacturing tolerances
+                            - Some dimension types require specific entity combinations
+        """
+        if hasattr(input_data, "model_dump"):
+            payload = input_data.model_dump()
+        else:
+            payload = dict(input_data)
+
+        dimension_type = payload.get("dimension_type")
+        entity1 = payload.get("entity1")
+        entity2 = payload.get("entity2")
+        position_x = payload.get("position_x")
+        position_y = payload.get("position_y")
+
+        if (entity1 is None or entity2 is None) and payload.get("entities"):
+            entities = payload["entities"]
+            if entity1 is None and len(entities) >= 1:
+                entity1 = entities[0]
+            if entity2 is None and len(entities) >= 2:
+                entity2 = entities[1]
+
+        if (position_x is None or position_y is None) and payload.get("position"):
+            position = payload["position"]
+            if len(position) >= 2:
+                if position_x is None:
+                    position_x = position[0]
+                if position_y is None:
+                    position_y = position[1]
+
+        # Feed the alias-normalized values back into the payload so the
+        # adapter call sees entity1/entity2/position_x/position_y even
+        # when the caller only supplied entities/position.
+        payload["entity1"] = entity1
+        payload["entity2"] = entity2
+        payload["position_x"] = position_x
+        payload["position_y"] = position_y
+
+        require_capability(
+            adapter,
+            "add_dimension",
+            f"Active adapter does not support add_dimension; no "
+            f"{dimension_type} dimension was added.",
+        )
+        result = await adapter.add_dimension(payload)
+        require_success(result, "Failed to add dimension")
+        return {
+            "status": "success",
+            "message": "Dimension added successfully",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_note(input_data: AddNoteInput) -> dict[str, Any]:
+        """Add a note or annotation to the current drawing.
+
+        Creates text annotations, callouts, and notes on drawings for specifications,
+        instructions, and additional manufacturing information. Essential for comprehensive
+        technical documentation.
+
+        Args:
+            input_data (AddNoteInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                                    ```python
+                                    # Add material specification note with leader
+                                    result = await add_note({
+                                        "text": "Material: AISI 1018 Steel
+                        Hardness: 150-200 HB",
+                                        "position_x": 200.0, "position_y": 50.0,
+                                        "font_size": 10.0,
+                                        "leader_attachment": "Face1"
+                                    })
+
+                                    if result["status"] == "success":
+                                        note = result["note"]
+                                        print(f"Added note at {note['font_size']}pt font size")
+                                        # Note provides critical manufacturing information
+                                    ```
+
+                                Note:
+                                    - Text supports standard annotation symbols and formatting
+                                    - Leader attachment improves clarity for specific features
+                                    - Font size should comply with drawing standards
+                                    - Position carefully to avoid dimension conflicts
+        """
+        require_capability(
+            adapter,
+            "add_note",
+            "Active adapter does not support add_note; no note was added.",
+        )
+        result = await adapter.add_note(input_data.model_dump())
+        require_success(result, "Failed to add note")
+        return {
+            "status": "success",
+            "message": f"Added note: {input_data.text[:30]}...",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def create_section_view(input_data: CreateSectionViewInput) -> dict[str, Any]:
+        """Create a section view of the current drawing.
+
+        Generates section views that show internal features by cutting through the part along a
+        specified section line. Essential for revealing hidden geometry, internal structures,
+        and complex assemblies.
+
+        Args:
+            input_data (CreateSectionViewInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create vertical section through center of part
+                            result = await create_section_view({
+                                "section_line_start": (50.0, 0.0),
+                                "section_line_end": (50.0, 100.0),
+                                "view_position_x": 300.0, "view_position_y": 150.0,
+                                "scale": 1.5,
+                                "label": "A"
+                            })
+
+                            if result["status"] == "success":
+                                section = result["section_view"]
+                                print(f"Created section {section['label']}-A at {section['scale']}:1")
+                                # Section reveals internal features clearly
+                            ```
+
+                        Note:
+                            - Section line direction determines view orientation
+                            - Section views automatically show cut surfaces with hatching
+                            - Label follows ANSI/ISO drafting standards (A-A, B-B, etc.)
+                            - Essential for showing internal features and assemblies
+        """
+        raise UnsupportedOperationError(
+            "No adapter capability exists for cutting a section view "
+            "along a section line; create_section_view cannot compute "
+            "the cut geometry, so no view was created. Use SolidWorks "
+            "directly (Insert > Drawing View > Section) instead."
+        )
+
+    @mcp.tool()
+    async def create_detail_view(input_data: CreateDetailViewInput) -> dict[str, Any]:
+        """Create a detail view of a specific area.
+
+        Generates magnified detail views of specific regions to show fine features, tight
+        tolerances, and intricate geometry that requires enhanced visibility for manufacturing
+        and inspection.
+
+        Args:
+            input_data (CreateDetailViewInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Create 4x detail view of small threaded hole
+                            result = await create_detail_view({
+                                "center_x": 25.0, "center_y": 15.0,
+                                "radius": 8.0,  # 16mm diameter detail area
+                                "view_position_x": 250.0, "view_position_y": 300.0,
+                                "scale": 4.0,   # 4:1 magnification
+                                "label": "A"
+                            })
+
+                            if result["status"] == "success":
+                                detail = result["detail_view"]
+                                print(f"Created detail {detail['label']} at {detail['scale']}:1")
+                                # Detail shows thread profile clearly for machining
+                            ```
+
+                        Note:
+                            - Detail circle size determines what geometry is magnified
+                            - Higher scale factors reveal fine features for precision work
+                            - Label follows standard drafting conventions (Detail A, etc.)
+                            - Essential for communicating tight tolerance requirements
+        """
+        raise UnsupportedOperationError(
+            "No adapter capability exists for magnifying the "
+            "geometry inside a detail circle; create_detail_view "
+            "cannot compute the detail geometry, so no view was "
+            "created. Use SolidWorks directly (Insert > Drawing "
+            "View > Detail) instead."
+        )
+
+    @mcp.tool()
+    async def update_sheet_format(input_data: UpdateSheetFormatInput) -> dict[str, Any]:
+        """Update the sheet format and title block information.
+
+        Applies drawing templates and updates title block fields with project information,
+        revision data, and drawing metadata. Essential for standardized documentation and
+        drawing control.
+
+        Args:
+            input_data (UpdateSheetFormatInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Apply company standard format with project info
+                            result = await update_sheet_format({
+                                "format_file": "C:/Templates/company_format.slddrt",
+                                "sheet_size": "A3",
+                                "title": "Mounting Bracket Assembly",
+                                "drawn_by": "J. Smith",
+                                "checked_by": "M. Johnson",
+                                "approved_by": "R. Wilson",
+                                "drawing_number": "DWG-001-Rev-A"
+                            })
+
+                            if result["status"] == "success":
+                                format_info = result["sheet_format"]
+                                print(f"Applied {format_info['sheet_size']} format")
+                                # Drawing now has proper title block and company branding
+                            ```
+
+                        Note:
+                            - Format file must exist and be compatible with SolidWorks version
+                            - Title block fields support company-specific customization
+                            - Sheet size affects drawing layout and scaling decisions
+                            - Essential for drawing control and document management systems
+        """
+        require_capability(
+            adapter,
+            "update_sheet_format",
+            "Active adapter does not support update_sheet_format; the "
+            "sheet format and title block were not changed.",
+        )
+        result = await adapter.update_sheet_format(input_data.model_dump())
+        require_success(result, "Failed to update sheet format")
+        return {
+            "status": "success",
+            "message": f"Updated sheet format to {input_data.sheet_size}",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def auto_dimension_view(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Automatically dimension a drawing view.
+
+        Analyzes drawing view geometry and automatically adds common dimensions including
+        overall sizes, hole diameters, radii, and critical features. Accelerates drawing
+        completion and ensures comprehensive dimensioning coverage.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Auto-dimension main view with baseline dimensions
+                            result = await auto_dimension_view({
+                                "view_name": "Front View",
+                                "dimension_types": ["linear", "diameter"],
+                                "include_baseline": True,
+                                "include_centerlines": True
+                            })
+
+                            if result["status"] == "success":
+                                auto_dims = result["auto_dimensions"]
+                                print(f"Added {auto_dims['dimensions_added']} dimensions")
+                                print(f"Coverage: {auto_dims['coverage']}")
+                                # Drawing now has comprehensive dimensioning
+                            ```
+
+                        Note:
+                            - Analyzes feature geometry to determine appropriate dimensions
+                            - Follows drafting standards for dimension placement
+                            - May require manual adjustment for optimal readability
+                            - Significantly reduces manual dimensioning time
+        """
+        require_capability(
+            adapter,
+            "auto_dimension_view",
+            "Active adapter does not support auto_dimension_view; no "
+            "dimensions were added.",
+        )
+        result = await adapter.auto_dimension_view(input_data)
+        require_success(result, "Failed to auto-dimension view")
+        return {
+            "status": "success",
+            "message": "Auto-dimensioned drawing view",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def check_drawing_standards(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Check the current drawing against drafting standards.
+
+        Validates drawing compliance with industry drafting standards including ANSI Y14.5, ISO
+        128, and DIN standards. Identifies non-compliance issues and provides recommendations
+        for improvement.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+
+        Example:
+                            ```python
+                            # Comprehensive ANSI standards check
+                            result = await check_drawing_standards({
+                                "standard": "ANSI",
+                                "check_categories": ["dimensions", "tolerances", "symbols"],
+                                "severity_filter": "warning"
+                            })
+
+                            if result["status"] == "success":
+                                check = result["standards_check"]
+                                print(f"Compliance Score: {check['compliance_score']}%")
+                                print(f"Warnings: {len(check['warnings'])}")
+                                print(f"Errors: {len(check['errors'])}")
+                                # Address issues to improve drawing quality
+                            ```
+
+                        Note:
+                            - Standards compliance ensures drawing acceptance in industry
+                            - Regular checking prevents costly revision cycles
+                            - Automated validation reduces human error in review process
+                            - Essential for quality management and ISO certification
+        """
+        raise UnsupportedOperationError(
+            "No adapter capability exists for checking drafting "
+            "standards compliance; check_drawing_standards cannot "
+            "inspect the drawing, so no compliance score was "
+            "computed. Use SolidWorks Design Checker for this."
+        )
+
+    @mcp.tool()
+    async def create_technical_drawing(
+        input_data: DrawingCreationInput,
+    ) -> dict[str, Any]:
+        """Create a technical drawing from a SolidWorks part or assembly.
+
+        Supports selecting a template, output path, sheet format, scale, and optional auto-
+        population of standard views for documentation.
+
+        Args:
+            input_data (DrawingCreationInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "create_technical_drawing",
+            "Active adapter does not support create_technical_drawing; "
+            "no drawing was created.",
+        )
+        result = await adapter.create_technical_drawing(input_data.model_dump())
+        require_success(result, "Failed to create technical drawing")
+        return {
+            "status": "success",
+            "message": "Technical drawing created successfully",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_drawing_view(input_data: DrawingViewInput) -> dict[str, Any]:
+        """Add, update, or remove a drawing view in an existing drawing.
+
+        Supports configuring the target drawing, view type, parent view, scale, and placement
+        coordinates for common drawing view workflows.
+
+        Args:
+            input_data (DrawingViewInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "add_drawing_view",
+            "Active adapter does not support add_drawing_view; no view was added.",
+        )
+        result = await adapter.add_drawing_view(input_data.model_dump())
+        require_success(result, "Failed to add drawing view")
+        return {
+            "status": "success",
+            "message": "Drawing view added successfully",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def add_annotation(input_data: AnnotationInput) -> dict[str, Any]:
+        """Add an annotation such as a note, balloon, or surface symbol.
+
+        Places annotation text in a drawing with optional font size, leader attachment, and
+        title-block style metadata fields.
+
+        Args:
+            input_data (AnnotationInput): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "add_annotation",
+            "Active adapter does not support add_annotation; no annotation was added.",
+        )
+        result = await adapter.add_annotation(input_data.model_dump())
+        require_success(result, "Failed to add annotation")
+        return {
+            "status": "success",
+            "message": "Annotation added successfully",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def update_title_block(input_data: dict[str, Any]) -> dict[str, Any]:
+        """Update title block fields for the active drawing.
+
+        Applies drawing metadata such as title, drawing number, and approval fields to keep
+        documentation aligned with standards.
+
+        Args:
+            input_data (dict[str, Any]): The input data value.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        require_capability(
+            adapter,
+            "update_title_block",
+            "Active adapter does not support update_title_block; the "
+            "title block was not changed.",
+        )
+        result = await adapter.update_title_block(input_data)
+        require_success(result, "Failed to update title block")
+        return {
+            "status": "success",
+            "message": "Title block updated successfully",
+            "data": result.data,
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def list_drawing_views() -> dict[str, Any]:
+        """List the views on the active drawing.
+
+        Read-only. Use it to find an existing view's name before targeting it
+        (e.g. with ``auto_center_marks``). Errors when the active document is
+        not a drawing.
+
+        Returns:
+            dict[str, Any]: ``status``, ``views`` (view names, sheet formats
+            excluded) and ``count``.
+
+        Example:
+            ```python
+            await list_drawing_views()
+            ```
+        """
+        result = await adapter.list_drawing_views()
+        require_success(result, context="Failed to list drawing views")
+        views = list(result.data or [])
+        return {
+            "status": "success",
+            "message": (
+                f"{len(views)} view(s): {', '.join(views)}"
+                if views
+                else "The drawing has no views"
+            ),
+            "views": views,
+            "count": len(views),
+            "execution_time": result.execution_time,
+        }
+
+    @mcp.tool()
+    async def auto_center_marks(
+        input_data: AutoCenterMarksInput,
+    ) -> dict[str, Any]:
+        """Auto-insert centre marks on circular features in a drawing view.
+
+        Runs SolidWorks' automatic centre-mark insertion for the named view.
+        The API does not report how many marks it added, so the response
+        gives the view's centre-mark count before and after and the delta.
+        A run that added nothing is still a success — the view may have no
+        un-marked holes.
+
+        Args:
+            input_data (AutoCenterMarksInput): The view and which feature
+                types to mark.
+
+        Returns:
+            dict[str, Any]: Status plus ``center_marks_before`` /
+            ``center_marks_after`` / ``center_marks_added``.
+
+        Example:
+            ```python
+            await auto_center_marks({"view_name": "Drawing View1"})
+            ```
+        """
+        require_capability(
+            adapter,
+            "auto_center_marks",
+            "Active adapter does not support auto_center_marks; "
+            "no centre marks were inserted.",
+        )
+        input_data = normalize_input(input_data, AutoCenterMarksInput)
+        result = await adapter.auto_center_marks(
+            input_data.view_name,
+            input_data.mark_holes,
+            input_data.mark_fillets,
+            input_data.mark_slots,
+        )
+        require_success(result, context="Failed to insert centre marks")
+        data = result.data if isinstance(result.data, dict) else {}
+        added = data.get("center_marks_added")
+        return {
+            "status": "success",
+            "message": (
+                f"Inserted {added} centre mark(s) on {input_data.view_name}"
+                if isinstance(added, int)
+                else f"Ran centre-mark insertion on {input_data.view_name}"
+            ),
+            "data": data,
+            "execution_time": result.execution_time,
+        }
+
+    tool_count = 14  # Number of tools registered
+    return tool_count