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

solidworks_mcp/adapters/base.py

@@ -0,0 +1,1882 @@
+"""Base adapter interface for SolidWorks integration.
+
+Defines the common interface that all SolidWorks adapters must implement, following the
+adapter pattern from the original TypeScript implementation.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import datetime
+from enum import StrEnum
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class AdapterHealth(BaseModel):
+    """Health status information for adapters.
+
+    Attributes:
+        average_response_time (float): The average response time value.
+        connection_status (str): The connection status value.
+        error_count (int): The error count value.
+        healthy (bool): The healthy value.
+        last_check (datetime): The last check value.
+        metrics (dict[str, Any] | None): The metrics value.
+        success_count (int): The success count value.
+    """
+
+    healthy: bool
+    last_check: datetime
+    error_count: int
+    success_count: int
+    average_response_time: float
+    connection_status: str
+    metrics: dict[str, Any] | None = None
+
+    def __getitem__(self, key: str) -> Any:
+        """Build internal getitem.
+
+        Args:
+            key (str): The key value.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        if key == "status":
+            return "healthy" if self.healthy else "unhealthy"
+        if key == "connected":
+            return self.connection_status == "connected"
+        if key == "adapter_type":
+            return (self.metrics or {}).get("adapter_type")
+        if key == "version":
+            return (self.metrics or {}).get("version", "mock-1.0")
+        if key == "uptime":
+            return (self.metrics or {}).get("uptime", 0.0)
+        return self.model_dump().get(key)
+
+    def __contains__(self, key: str) -> bool:
+        """Build internal contains.
+
+        Args:
+            key (str): The key value.
+
+        Returns:
+            bool: True if contains, otherwise False.
+        """
+        legacy_keys = {"status", "connected", "adapter_type", "version", "uptime"}
+        if key in legacy_keys:
+            return True
+        return key in self.model_dump()
+
+
+class AdapterResultStatus(StrEnum):
+    """Result status for adapter operations.
+
+    Attributes:
+        ERROR (Any): The error value.
+        SUCCESS (Any): The success value.
+        TIMEOUT (Any): The timeout value.
+        WARNING (Any): The warning value.
+    """
+
+    SUCCESS = "success"
+    ERROR = "error"
+    WARNING = "warning"
+    TIMEOUT = "timeout"
+
+
+@dataclass
+class AdapterResult[T]:
+    """Result wrapper for adapter operations.
+
+    Attributes:
+        data (T | None): The data value.
+        error (str | None): The error value.
+        execution_time (float | None): The execution time value.
+        metadata (dict[str, Any] | None): The metadata value.
+        status (AdapterResultStatus): The status value.
+    """
+
+    status: AdapterResultStatus
+    data: T | None = None
+    error: str | None = None
+    execution_time: float | None = None
+    metadata: dict[str, Any] | None = None
+
+    @property
+    def is_success(self) -> bool:
+        """Check if operation was successful.
+
+        Returns:
+            bool: True if success, otherwise False.
+        """
+        return self.status == AdapterResultStatus.SUCCESS
+
+    @property
+    def is_error(self) -> bool:
+        """Check if operation had an error.
+
+        Returns:
+            bool: True if error, otherwise False.
+        """
+        return self.status == AdapterResultStatus.ERROR
+
+
+# SolidWorks data models
+class SolidWorksModel(BaseModel):
+    """SolidWorks model information.
+
+    Attributes:
+        configuration (str | None): The configuration value.
+        is_active (bool): The is active value.
+        name (str): The name value.
+        path (str): The path value.
+        properties (dict[str, Any] | None): The properties value.
+        type (str): The type value.
+    """
+
+    path: str
+    name: str
+    type: str  # "Part", "Assembly", "Drawing"
+    is_active: bool
+    configuration: str | None = None
+    properties: dict[str, Any] | None = None
+
+    def __getitem__(self, key: str) -> Any:
+        """Build internal getitem.
+
+        Args:
+            key (str): The key value.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        if key == "title":
+            return self.name
+        if key == "units":
+            return (self.properties or {}).get("units")
+        return self.model_dump().get(key)
+
+
+class SolidWorksFeature(BaseModel):
+    """SolidWorks feature information.
+
+    Attributes:
+        id (str | None): The id value.
+        name (str): The name value.
+        parameters (dict[str, Any] | None): The parameters value.
+        parent (str | None): The parent value.
+        properties (dict[str, Any] | None): The properties value.
+        type (str): The type value.
+    """
+
+    name: str
+    type: str
+    id: str | None = None
+    parent: str | None = None
+    properties: dict[str, Any] | None = None
+    parameters: dict[str, Any] | None = None
+
+    def __getitem__(self, key: str) -> Any:
+        """Build internal getitem.
+
+        Args:
+            key (str): The key value.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        if self.parameters and key in self.parameters:
+            return self.parameters.get(key)
+        return self.model_dump().get(key)
+
+
+class ExtrusionParameters(BaseModel):
+    """Parameters for extrusion operations.
+
+    Attributes:
+        auto_select (bool): The auto select value.
+        both_directions (bool): The both directions value.
+        depth (float): The depth value.
+        draft_angle (float): The draft angle value.
+        end_condition (str): The end condition value.
+        feature_scope (bool): The feature scope value.
+        merge_result (bool): The merge result value.
+        reverse_direction (bool): The reverse direction value.
+        sketch_name (str | None): Explicit sketch to operate on. When set,
+            callers (e.g. create_cut_extrude) must select exactly this
+            sketch and fail with a clear error if it doesn't exist rather
+            than silently falling back to some other sketch.
+        thin_feature (bool): The thin feature value.
+        thin_thickness (float | None): The thin thickness value.
+        up_to_surface (str | None): The up to surface value.
+    """
+
+    depth: float
+    draft_angle: float = 0.0
+    reverse_direction: bool = False
+    both_directions: bool = False
+    thin_feature: bool = False
+    thin_thickness: float | None = None
+    auto_fillet_corners: bool = False
+    fillet_corners_radius: float = 0.0
+    end_condition: str = "Blind"
+    up_to_surface: str | None = None
+    merge_result: bool = True
+    feature_scope: bool = False
+    auto_select: bool = True
+    sketch_name: str | None = None
+
+
+class RevolveParameters(BaseModel):
+    """Parameters for revolve operations.
+
+    Attributes:
+        angle (float): The angle value.
+        both_directions (bool): The both directions value.
+        merge_result (bool): The merge result value.
+        reverse_direction (bool): The reverse direction value.
+        thin_feature (bool): The thin feature value.
+        thin_thickness (float | None): The thin thickness value.
+    """
+
+    angle: float
+    reverse_direction: bool = False
+    both_directions: bool = False
+    thin_feature: bool = False
+    thin_thickness: float | None = None
+    merge_result: bool = True
+
+
+class SweepParameters(BaseModel):
+    """Parameters for sweep operations.
+
+    Attributes:
+        merge_result (bool): The merge result value.
+        path (str): The path value.
+        twist_along_path (bool): The twist along path value.
+        twist_angle (float): The twist angle value.
+    """
+
+    path: str
+    twist_along_path: bool = False
+    twist_angle: float = 0.0
+    merge_result: bool = True
+
+
+class LoftParameters(BaseModel):
+    """Parameters for loft operations.
+
+    Attributes:
+        end_tangent (str | None): The end tangent value.
+        guide_curves (list[str] | None): The guide curves value.
+        merge_result (bool): The merge result value.
+        profiles (list[str]): The profiles value.
+        start_tangent (str | None): The start tangent value.
+    """
+
+    profiles: list[str]
+    guide_curves: list[str] | None = None
+    start_tangent: str | None = None
+    end_tangent: str | None = None
+    merge_result: bool = True
+
+
+class MassProperties(BaseModel):
+    """Mass properties information.
+
+    Attributes:
+        center_of_mass (list[float]): The center of mass value.
+        mass (float): The mass value.
+        moments_of_inertia (dict[str, float]): The moments of inertia value.
+        principal_axes (dict[str, list[float]] | None): The principal axes value.
+        surface_area (float): The surface area value.
+        volume (float): The volume value.
+    """
+
+    volume: float
+    surface_area: float
+    mass: float
+    center_of_mass: list[float]  # [x, y, z]
+    moments_of_inertia: dict[str, float]
+    principal_axes: dict[str, list[float]] | None = None
+
+
+class SolidWorksAdapter(ABC):
+    """Base adapter interface for SolidWorks integration.
+
+    Args:
+        config (object | None): Configuration values for the operation. Defaults to None.
+
+    Attributes:
+        _metrics (Any): The metrics value.
+        config (Any): The config value.
+        config_dict (Any): The config dict value.
+    """
+
+    def __init__(self, config: object | None = None):
+        """Initialize adapter with configuration.
+
+        Args:
+            config (object | None): Configuration values for the operation. Defaults to None.
+        """
+        if config is None:
+            normalized_config: dict[str, Any] = {}
+        elif isinstance(config, Mapping):
+            normalized_config = dict(config)
+        elif hasattr(config, "model_dump"):
+            normalized_config = dict(config.model_dump())
+        else:
+            normalized_config = {}
+
+        # Preserve original config object for compatibility with tests and
+        # call sites that compare object identity/equality.
+        self.config = config
+        # Keep a normalized mapping for adapter internals.
+        self.config_dict = normalized_config
+        self._metrics = {
+            "operations_count": 0,
+            "errors_count": 0,
+            "average_response_time": 0.0,
+        }
+        # SolidWorks-as-Code session logging. Set soc_session_id to enable
+        # automatic ToolCallRecord writes for every adapter operation.
+        self.soc_session_id: str | None = None
+        self.soc_db_path: Path | None = None
+
+    # Connection Management
+    @abstractmethod
+    async def connect(self) -> None:
+        """Connect to SolidWorks application.
+
+        Returns:
+            None: None.
+        """
+        pass
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Disconnect from SolidWorks application.
+
+        Returns:
+            None: None.
+        """
+        pass
+
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Check if connected to SolidWorks.
+
+        Returns:
+            bool: True if connected, otherwise False.
+        """
+        pass
+
+    @abstractmethod
+    async def health_check(self) -> AdapterHealth:
+        """Get adapter health status.
+
+        Returns:
+            AdapterHealth: The result produced by the operation.
+        """
+        pass
+
+    # Model Operations
+    @abstractmethod
+    async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
+        """Open a SolidWorks model (part, assembly, or drawing).
+
+        Args:
+            file_path (str): Path to the target file.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def close_model(self, save: bool = False) -> AdapterResult[None]:
+        """Close the current model.
+
+        Args:
+            save (bool): The save value. Defaults to False.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        pass
+
+    async def save_file(self, file_path: str | None = None) -> AdapterResult[Any]:
+        """Save the active model to the existing path or the provided path.
+
+        Args:
+            file_path (str | None): Path to the target file. Defaults to None.
+
+        Returns:
+            AdapterResult[Any]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="save_file is not implemented by this adapter",
+        )
+
+    @abstractmethod
+    async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
+        """Get metadata for the active model.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def list_features(
+        self, include_suppressed: bool = False, max_assembly_depth: int = 2
+    ) -> AdapterResult[list[dict[str, Any]]]:
+        """List model features from the feature tree.
+
+        For a Part document, returns that document's own feature list,
+        unchanged from prior behavior. For an Assembly document, returns a
+        single flat list containing the assembly's own top-level features
+        plus every resolved component's features, recursing into
+        sub-assemblies up to ``max_assembly_depth``. Every descriptor gains
+        ``component``, ``component_path``, and ``component_parent`` keys:
+        ``None`` for a document's own features (Part features, or an Assembly's
+        top-level features), or the owning component's name/path for a
+        component-derived feature. ``component_parent`` is the immediate parent
+        component name when the component is nested inside a sub-assembly,
+        otherwise ``None``. A component that cannot be resolved (suppressed,
+        lightweight-and-unloaded, missing file) is represented by one descriptor
+        with ``type: "UnresolvedComponent"`` instead of being silently dropped.
+
+        Args:
+            include_suppressed (bool): The include suppressed value. Defaults to False.
+                Applied independently to the assembly's own features and to
+                each component's features.
+            max_assembly_depth (int): How many levels of sub-assembly to
+                recurse into. Defaults to 2. Ignored for Part documents. A
+                component beyond the configured depth still appears in the
+                result as a single descriptor (name + path), not expanded.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def list_configurations(self) -> AdapterResult[list[str]]:
+        """List configuration names for the active model.
+
+        Returns:
+            AdapterResult[list[str]]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_part(
+        self,
+        name: str | None = None,
+        units: str | None = None,
+        template: str | None = None,
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new part document.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            units (str | None): The units value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_assembly(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new assembly document.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_drawing(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new drawing document.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        pass
+
+    # Feature Operations
+    @abstractmethod
+    async def create_extrusion(
+        self, params: ExtrusionParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Create an extrusion feature.
+
+        Args:
+            params (ExtrusionParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_revolve(
+        self, params: RevolveParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Create a revolve feature.
+
+        Args:
+            params (RevolveParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_sweep(
+        self, params: SweepParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Create a sweep feature.
+
+        Args:
+            params (SweepParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def create_loft(
+        self, params: LoftParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Create a loft feature.
+
+        Args:
+            params (LoftParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        pass
+
+    # Sketch Operations
+    @abstractmethod
+    async def create_sketch(self, plane: str) -> AdapterResult[str]:
+        """Create a new sketch on the specified plane.
+
+        Args:
+            plane (str): The plane value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def add_line(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Add a line to the current sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def add_circle(
+        self, center_x: float, center_y: float, radius: float
+    ) -> AdapterResult[str]:
+        """Add a circle to the current sketch.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            radius (float): The radius value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def add_rectangle(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Add a rectangle to the current sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        pass
+
+    async def add_arc(
+        self,
+        center_x: float,
+        center_y: float,
+        start_x: float,
+        start_y: float,
+        end_x: float,
+        end_y: float,
+    ) -> AdapterResult[str]:
+        """Add an arc to the current sketch.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            start_x (float): The start x value.
+            start_y (float): The start y value.
+            end_x (float): The end x value.
+            end_y (float): The end y value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_arc is not implemented by this adapter",
+        )
+
+    async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
+        """Add a spline through the provided points.
+
+        Args:
+            points (list[dict[str, float]]): The points value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_spline is not implemented by this adapter",
+        )
+
+    async def add_centerline(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Add a centerline to the current sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_centerline is not implemented by this adapter",
+        )
+
+    async def add_polygon(
+        self, center_x: float, center_y: float, radius: float, sides: int
+    ) -> AdapterResult[str]:
+        """Add a regular polygon to the current sketch.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            radius (float): The radius value.
+            sides (int): The sides value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_polygon is not implemented by this adapter",
+        )
+
+    async def add_ellipse(
+        self,
+        center_x: float,
+        center_y: float,
+        major_axis: float,
+        minor_axis: float,
+    ) -> AdapterResult[str]:
+        """Add an ellipse to the current sketch.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            major_axis (float): The major axis value.
+            minor_axis (float): The minor axis value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_ellipse is not implemented by this adapter",
+        )
+
+    async def add_sketch_constraint(
+        self,
+        entity1: str,
+        entity2: str | None,
+        relation_type: str,
+        entity3: str | None = None,
+    ) -> AdapterResult[str]:
+        """Apply a geometric constraint between sketch entities.
+
+        Args:
+            entity1 (str): The entity1 value.
+            entity2 (str | None): The entity2 value.
+            relation_type (str): The relation type value.
+            entity3 (str | None): Third entity ID — only used by the
+                ``symmetric`` relation (the centerline of symmetry). All
+                other relation types reject a non-null ``entity3``.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_sketch_constraint is not implemented by this adapter",
+        )
+
+    async def add_sketch_dimension(
+        self,
+        entity1: str,
+        entity2: str | None,
+        dimension_type: str,
+        value: float,
+    ) -> AdapterResult[str]:
+        """Add a sketch dimension.
+
+        Args:
+            entity1 (str): The entity1 value.
+            entity2 (str | None): The entity2 value.
+            dimension_type (str): The dimension type value.
+            value (float): The value value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_sketch_dimension is not implemented by this adapter",
+        )
+
+    async def check_sketch_fully_defined(
+        self, sketch_name: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Check whether a sketch is fully defined.
+
+        Args:
+            sketch_name (str | None): Optional sketch name to inspect. Defaults to None.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Definition status payload.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="check_sketch_fully_defined is not implemented by this adapter",
+        )
+
+    async def sketch_linear_pattern(
+        self,
+        entities: list[str],
+        direction_x: float,
+        direction_y: float,
+        spacing: float,
+        count: int,
+    ) -> AdapterResult[str]:
+        """Create a linear pattern of sketch entities.
+
+        Args:
+            entities (list[str]): The entities value.
+            direction_x (float): The direction x value.
+            direction_y (float): The direction y value.
+            spacing (float): The spacing value.
+            count (int): The count value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="sketch_linear_pattern is not implemented by this adapter",
+        )
+
+    async def sketch_circular_pattern(
+        self,
+        entities: list[str],
+        angle: float,
+        count: int,
+    ) -> AdapterResult[str]:
+        """Create a circular pattern of sketch entities around the sketch origin.
+
+        The rotation axis is always the sketch origin — SW's
+        ``CreateCircularSketchStepAndRepeat`` has no pattern-centre
+        parameter and derives the axis from the seed's geometry. Place
+        the seed entity at the desired radius from the origin.
+
+        Args:
+            entities (list[str]): The entities value.
+            angle (float): The angle value.
+            count (int): The count value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="sketch_circular_pattern is not implemented by this adapter",
+        )
+
+    async def sketch_mirror(
+        self, entities: list[str], mirror_line: str
+    ) -> AdapterResult[str]:
+        """Mirror sketch entities about a mirror line.
+
+        Args:
+            entities (list[str]): The entities value.
+            mirror_line (str): The mirror line value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="sketch_mirror is not implemented by this adapter",
+        )
+
+    async def sketch_offset(
+        self,
+        entities: list[str],
+        offset_distance: float,
+        reverse_direction: bool,
+    ) -> AdapterResult[str]:
+        """Offset sketch entities.
+
+        Args:
+            entities (list[str]): The entities value.
+            offset_distance (float): The offset distance value.
+            reverse_direction (bool): The reverse direction value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="sketch_offset is not implemented by this adapter",
+        )
+
+    async def add_sketch_circle(
+        self,
+        center_x: float,
+        center_y: float,
+        radius: float,
+        construction: bool = False,
+    ) -> AdapterResult[str]:
+        """Alias for add_circle used by some tool flows.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            radius (float): The radius value.
+            construction (bool): The construction value. Defaults to False.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return await self.add_circle(center_x, center_y, radius)
+
+    async def create_cut(self, sketch_name: str, depth: float) -> AdapterResult[str]:
+        """Create a cut feature from an existing sketch.
+
+        Args:
+            sketch_name (str): The sketch name value.
+            depth (float): The depth value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_cut is not implemented by this adapter",
+        )
+
+    async def create_cut_extrude(
+        self, params: ExtrusionParameters
+    ) -> AdapterResult[Any]:
+        """Create a cut-extrude feature from the active sketch.
+
+        Cuts material from the current solid body using the active sketch profile.
+        Equivalent to SolidWorks Insert > Cut > Extrude.
+
+        Args:
+            params (ExtrusionParameters): Depth and direction parameters.
+
+        Returns:
+            AdapterResult: Feature result or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_cut_extrude is not implemented by this adapter",
+        )
+
+    async def add_fillet(
+        self, radius: float, edge_names: list[str]
+    ) -> AdapterResult[Any]:
+        """Add a fillet feature to selected edges.
+
+        Rounds the selected edges of the current solid body with the given radius.
+
+        Args:
+            radius (float): Fillet radius in millimeters.
+            edge_names (list[str]): List of edge names to fillet.
+
+        Returns:
+            AdapterResult: Feature result or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_fillet is not implemented by this adapter",
+        )
+
+    async def add_chamfer(
+        self, distance: float, edge_names: list[str]
+    ) -> AdapterResult[Any]:
+        """Add an equal-distance chamfer feature to selected edges.
+
+        Chamfers the selected edges of the current solid body by the given
+        distance.
+
+        Args:
+            distance (float): Chamfer distance in millimeters.
+            edge_names (list[str]): List of edge names to chamfer.
+
+        Returns:
+            AdapterResult: Feature result or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_chamfer is not implemented by this adapter",
+        )
+
+    async def get_selected_entities(self) -> AdapterResult[list[dict[str, Any]]]:
+        """Report the faces/edges/vertices currently selected in the live UI.
+
+        Lets an agent see exactly what the user has clicked on in SolidWorks
+        (e.g. "chamfer THIS face") instead of inferring it from a screenshot.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: One descriptor per selected
+            entity. See the PyWin32 adapter's implementation for the field
+            set (varies by entity type).
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="get_selected_entities is not implemented by this adapter",
+        )
+
+    async def select_feature(
+        self, feature_name: str, append: bool = False
+    ) -> AdapterResult[dict[str, Any]]:
+        """Select a named feature, sketch, plane or component.
+
+        Args:
+            feature_name (str): The feature name, optionally ``@document``
+                qualified.
+            append (bool): Add to the current selection instead of replacing
+                it. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: On success ``selected`` (True),
+            ``feature_name``, ``selected_name``, ``entity_type`` and
+            ``selection_count``. ERROR when nothing could be selected - never
+            SUCCESS with ``selected: False``.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="select_feature is not implemented by this adapter",
+        )
+
+    async def select_face_edges(
+        self,
+        point: list[float] | None = None,
+        side: str | None = None,
+        plane: str | None = None,
+        edge_type: str = "all",
+        append: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Multi-select every edge bounding one face of the active part.
+
+        Exactly one of ``point``/``side``/``plane`` identifies the face.
+
+        Args:
+            point (list[float] | None): ``[x, y, z]`` in mm on the face.
+            side (str | None): ``+X``..``-Z`` or ``top/bottom/front/back/
+                right/left``; the furthest planar face facing that way.
+            plane (str | None): Reference plane name; the body face(s) lying
+                on it.
+            edge_type (str): ``all``, ``linear`` or ``circular``.
+            append (bool): Add to the current selection. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``face`` (or ``faces``), ``edges``
+            (one descriptor per selected edge) and ``selection_count``.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="select_face_edges is not implemented by this adapter",
+        )
+
+    async def rebuild_model(
+        self, top_level_only: bool = False
+    ) -> AdapterResult[dict[str, Any]]:
+        """Force a rebuild and report per-feature rebuild errors.
+
+        Args:
+            top_level_only (bool): Rebuild only the top level of an assembly.
+                Defaults to False (full rebuild).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``rebuilt``, ``top_level_only``,
+            ``errors`` (one entry per failing feature with ``feature``,
+            ``type``, ``code``, ``code_name``, ``severity``, ``description``,
+            ``parents``, ``hint``), ``error_count`` and ``warning_count``.
+            ERROR (still carrying ``data``) when any error-severity entry
+            remains.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="rebuild_model is not implemented by this adapter",
+        )
+
+    async def create_reference_plane(
+        self,
+        reference: str,
+        offset: float = 0.0,
+        angle: float = 0.0,
+        flip: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Create a reference plane offset from, or angled to, an existing plane.
+
+        Args:
+            reference (str): Name of the reference plane or planar face.
+            offset (float): Offset distance in millimetres. Defaults to 0.0.
+            angle (float): Angle in degrees. Defaults to 0.0.
+            flip (bool): Reverse the offset or angle direction. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new plane's name and parameters, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_reference_plane is not implemented by this adapter",
+        )
+
+    async def create_axis(self, reference: str) -> AdapterResult[dict[str, Any]]:
+        """Create a reference axis along a principal direction.
+
+        Args:
+            reference (str): "x", "y" or "z" (case-insensitive, leading +/- stripped).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The plane pair used and feature counts, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_axis is not implemented by this adapter",
+        )
+
+    async def create_reference_point(
+        self,
+        mode: str,
+        x: float,
+        y: float,
+        z: float,
+        distance: float | None = None,
+        percent: float | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Create a reference point on the active part.
+
+        Args:
+            mode (str): "along_curve" or "face_center".
+            x (float): X of a point on the target edge/face, in millimetres.
+            y (float): Y of a point on the target edge/face, in millimetres.
+            z (float): Z of a point on the target edge/face, in millimetres.
+            distance (float | None): For "along_curve", offset from the edge
+                start in millimetres.
+            percent (float | None): For "along_curve", position as 0-100 of
+                the edge length.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The mode and feature counts, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_reference_point is not implemented by this adapter",
+        )
+
+    async def mirror_feature(
+        self,
+        features: list[str],
+        mirror_plane: str,
+        merge: bool = True,
+        mirror_bodies: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mirror solid bodies or features about a plane.
+
+        Args:
+            features (list[str]): Body or feature names to mirror.
+            mirror_plane (str): Plane name to mirror about.
+            merge (bool): Merge the mirrored result with the original. Defaults to True.
+            mirror_bodies (bool): Mirror whole bodies rather than features. Defaults to True.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The mirror feature's name, inputs and volume
+            before/after, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="mirror_feature is not implemented by this adapter",
+        )
+
+    async def pattern_circular(
+        self,
+        features: list[str],
+        axis: str,
+        count: int,
+        angle: float = 360.0,
+        equal_spacing: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Pattern features around an axis.
+
+        Args:
+            features (list[str]): Names of the features to pattern.
+            axis (str): Name of the axis to rotate about.
+            count (int): Total number of instances including the original.
+            angle (float): Total angle in degrees to spread them over. Defaults to 360.0.
+            equal_spacing (bool): Space instances evenly across ``angle``. Defaults to True.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: What was patterned and the volume
+            before/after, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="pattern_circular is not implemented by this adapter",
+        )
+
+    # Assembly Operations
+    async def insert_component(
+        self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
+    ) -> AdapterResult[dict[str, Any]]:
+        """Insert a part or sub-assembly into the active assembly.
+
+        Args:
+            file_path (str): Absolute path to the ``.sldprt`` or ``.sldasm``.
+            x (float): X position in millimetres. Defaults to 0.0.
+            y (float): Y position in millimetres. Defaults to 0.0.
+            z (float): Z position in millimetres. Defaults to 0.0.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Component name and counts, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="insert_component is not implemented by this adapter",
+        )
+
+    async def list_components(self) -> AdapterResult[list[str]]:
+        """List the top-level components of the active assembly.
+
+        Returns:
+            AdapterResult[list[str]]: Component instance names, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="list_components is not implemented by this adapter",
+        )
+
+    async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
+        """Summarise the active part or assembly without changing it.
+
+        Must not rebuild the model, modify it, or clear the selection, so
+        callers can read it around a feature call. Values the adapter cannot
+        determine are ``None``, never guessed.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``document_type`` (``"part"`` or
+            ``"assembly"``), ``volume_mm3``, ``bounding_box_mm`` (``min``,
+            ``max`` and ``size`` as ``[x, y, z]``), ``bounding_box_method``,
+            ``solid_body_count``, and for assemblies ``component_count`` and
+            ``mate_count``. Error when there is no active part or assembly.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="get_model_geometry_summary is not implemented by this adapter",
+        )
+
+    async def add_mate(
+        self,
+        component_a: str,
+        component_b: str,
+        entity_a: str = "Front Plane",
+        entity_b: str = "Front Plane",
+        mate_type: str = "coincident",
+        alignment: str = "aligned",
+        distance: float = 0.0,
+        angle: float = 0.0,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mate two components together in the active assembly.
+
+        Args:
+            component_a (str): First component instance name.
+            component_b (str): Second component instance name.
+            entity_a (str): Named feature on the first component. Defaults to
+                "Front Plane".
+            entity_b (str): Named feature on the second component. Defaults to
+                "Front Plane".
+            mate_type (str): Mate type, e.g. ``coincident``. Defaults to
+                "coincident".
+            alignment (str): ``aligned``, ``anti_aligned`` or ``closest``.
+                Defaults to "aligned".
+            distance (float): Distance in millimetres, for a distance mate.
+                Defaults to 0.0.
+            angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Mate details, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_mate is not implemented by this adapter",
+        )
+
+    # Drawing Operations
+    async def create_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Place a view of a model on the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the model path, orientation,
+                position in millimetres and optional view scale.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new view's details, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_drawing_view is not implemented by this adapter",
+        )
+
+    async def add_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Add a view of a model to the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the model path, orientation,
+                position in millimetres and optional view scale.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new view's details, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_drawing_view is not implemented by this adapter",
+        )
+
+    async def create_technical_drawing(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Lay out the standard views of a model on the active sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the model path and the
+                projection angle.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The view names created, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_technical_drawing is not implemented by this adapter",
+        )
+
+    async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
+        """Place a text note on the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the note text, its position in
+                millimetres and an optional font size in points.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The note's details, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_note is not implemented by this adapter",
+        )
+
+    async def list_drawing_views(self) -> AdapterResult[list[str]]:
+        """List the views on the active drawing.
+
+        Returns:
+            AdapterResult[list[str]]: View names, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="list_drawing_views is not implemented by this adapter",
+        )
+
+    async def auto_center_marks(
+        self,
+        view_name: str,
+        mark_holes: bool = True,
+        mark_fillets: bool = False,
+        mark_slots: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Auto-insert centre marks on circular features in a drawing view.
+
+        Args:
+            view_name (str): Name of a view on the active drawing.
+            mark_holes (bool): Mark holes / bores.
+            mark_fillets (bool): Mark fillets.
+            mark_slots (bool): Mark slots.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The view and before/after centre-mark
+            counts, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="auto_center_marks is not implemented by this adapter",
+        )
+
+    async def save_body_as_part(
+        self, body_name: str, file_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Extract one solid body from the active multibody part to a new file.
+
+        Args:
+            body_name (str): Name of a solid body in the active part.
+            file_path (str): Absolute path for the new ``.sldprt``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The body, the written path, and the
+            solid-body names found, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="save_body_as_part is not implemented by this adapter",
+        )
+
+    async def check_interference(
+        self, params: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Check the active assembly for interfering components.
+
+        Args:
+            params (Any): Optional settings; ``coincident``, ``components``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Interference details, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="check_interference is not implemented by this adapter",
+        )
+
+    # Feature Editing
+    async def delete_feature(self, name: str) -> AdapterResult[dict[str, Any]]:
+        """Delete a named feature or sketch from the active model.
+
+        Args:
+            name (str): Feature or sketch name.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: What was deleted, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="delete_feature is not implemented by this adapter",
+        )
+
+    async def suppress_feature(
+        self, name: str, suppress: bool = True
+    ) -> AdapterResult[dict[str, Any]]:
+        """Suppress or unsuppress a named feature.
+
+        Args:
+            name (str): Feature name.
+            suppress (bool): True to suppress, False to unsuppress.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The resulting state, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="suppress_feature is not implemented by this adapter",
+        )
+
+    async def rename_feature(
+        self, old_name: str, new_name: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Rename an existing feature on the feature tree.
+
+        Args:
+            old_name (str): Current feature name.
+            new_name (str): New feature name.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The old and new names, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="rename_feature is not implemented by this adapter",
+        )
+
+    async def undo(self, count: int = 1) -> AdapterResult[dict[str, Any]]:
+        """Undo the last operations in the active model.
+
+        Args:
+            count (int): Number of steps to undo.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Whether the tree changed, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="undo is not implemented by this adapter",
+        )
+
+    async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
+        """Set the active document's linear unit system.
+
+        Args:
+            unit_system (str): One of ``mm``, ``cm``, ``m``, ``in``, ``ft``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: What was applied, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="set_units is not implemented by this adapter",
+        )
+
+    async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
+        """Enumerate every document currently open in SolidWorks.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: One entry per open document
+            (``title``, ``path``, ``type``, ``is_active``), or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="list_open_documents is not implemented by this adapter",
+        )
+
+    async def activate_document(
+        self, title_or_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Make an already-open document the active one.
+
+        Args:
+            title_or_path (str): Title, full path, or file name of an open
+                document.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: What was activated, or error.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="activate_document is not implemented by this adapter",
+        )
+
+    @abstractmethod
+    async def exit_sketch(self) -> AdapterResult[None]:
+        """Exit sketch editing mode.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        pass
+
+    # Analysis Operations
+    @abstractmethod
+    async def get_mass_properties(self) -> AdapterResult[MassProperties]:
+        """Get mass properties of the current model.
+
+        Returns:
+            AdapterResult[MassProperties]: The result produced by the operation.
+        """
+        pass
+
+    # Export Operations
+    @abstractmethod
+    async def export_image(self, payload: dict) -> AdapterResult[dict]:
+        """Export a viewport screenshot (PNG/JPG) of the current model.
+
+        Payload keys: file_path (str): Absolute output path. width (int): Image width in pixels.
+        height (int): Image height in pixels. view_orientation (str): One of "isometric",
+        "front", "top", "right", "back", "bottom", "current".
+
+        Args:
+            payload (dict): The payload value.
+
+        Returns:
+            AdapterResult[dict]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def export_file(
+        self, file_path: str, format_type: str
+    ) -> AdapterResult[None]:
+        """Export the current model to a file.
+
+        Args:
+            file_path (str): Path to the target file.
+            format_type (str): The format type value.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        pass
+
+    # Dimension Operations
+    @abstractmethod
+    async def get_dimension(self, name: str) -> AdapterResult[float]:
+        """Get the value of a dimension.
+
+        Args:
+            name (str): The name value.
+
+        Returns:
+            AdapterResult[float]: The result produced by the operation.
+        """
+        pass
+
+    @abstractmethod
+    async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
+        """Set the value of a dimension.
+
+        Args:
+            name (str): The name value.
+            value (float): The value value.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        pass
+
+    # Utility Methods
+    def update_metrics(self, operation_time: float, success: bool) -> None:
+        """Update adapter metrics.
+
+        Args:
+            operation_time (float): The operation time value.
+            success (bool): The success value.
+
+        Returns:
+            None: None.
+        """
+        self._metrics["operations_count"] += 1
+        if not success:
+            self._metrics["errors_count"] += 1
+
+        # Update average response time
+        current_avg = self._metrics["average_response_time"]
+        count = self._metrics["operations_count"]
+        self._metrics["average_response_time"] = (
+            current_avg * (count - 1) + operation_time
+        ) / count
+
+    def get_metrics(self) -> dict[str, Any]:
+        """Get adapter metrics.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the resulting values.
+        """
+        return self._metrics.copy()
+
+    # --- Engineering-data and drawing-documentation methods ---
+
+    async def list_model_dimensions(
+        self,
+        feature_name: str | None = None,
+    ) -> AdapterResult[list[dict[str, Any]]]:
+        """List every dimension in the active part or assembly.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="list_model_dimensions is not implemented by this adapter",
+        )
+
+    async def measure_entities(
+        self,
+        entities: list[str],
+    ) -> AdapterResult[dict[str, Any]]:
+        """Measure one or two selected entities.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="measure_entities is not implemented by this adapter",
+        )
+
+    async def get_material(
+        self,
+        configuration: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Read the material assigned to the active part.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="get_material is not implemented by this adapter",
+        )
+
+    async def set_material(
+        self,
+        material_name: str,
+        database: str | None = None,
+        configuration: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Assign a material to the active part.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="set_material is not implemented by this adapter",
+        )
+
+    async def list_available_materials(
+        self,
+        search: str | None = None,
+    ) -> AdapterResult[list[dict[str, str]]]:
+        """List materials from the configured material libraries.
+
+        Returns:
+            AdapterResult[list[dict[str, str]]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="list_available_materials is not implemented by this adapter",
+        )
+
+    async def get_custom_properties(
+        self,
+        configuration: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Read the custom properties of the active document.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="get_custom_properties is not implemented by this adapter",
+        )
+
+    async def set_custom_property(
+        self,
+        name: str,
+        value: str,
+        configuration: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Create or overwrite one custom property.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="set_custom_property is not implemented by this adapter",
+        )
+
+    async def export_flat_pattern(
+        self,
+        file_path: str,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Export the active sheet-metal part's flat pattern.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="export_flat_pattern is not implemented by this adapter",
+        )
+
+    async def insert_model_dimensions(
+        self,
+        view_name: str | None = None,
+        include_hole_wizard: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Bring model dimensions into drawing views.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="insert_model_dimensions is not implemented by this adapter",
+        )
+
+    async def arrange_dimensions(
+        self,
+        view_name: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Move drawing dimensions so none overlaps, then verify.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="arrange_dimensions is not implemented by this adapter",
+        )
+
+    async def insert_bom_table(
+        self,
+        view_name: str,
+        template_path: str | None = None,
+        bom_type: str = "top_level_only",
+        x_mm: float | None = None,
+        y_mm: float | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Insert a BOM table anchored to an assembly drawing view.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="insert_bom_table is not implemented by this adapter",
+        )
+
+    async def set_sheet_scale(
+        self,
+        numerator: float,
+        denominator: float,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Set the active drawing sheet's scale.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="set_sheet_scale is not implemented by this adapter",
+        )
+
+    async def add_gtol(
+        self,
+        characteristic: str,
+        tolerance: float,
+        x_mm: float,
+        y_mm: float,
+        diameter_zone: bool = False,
+        material_condition: str = "none",
+        datums: list[str] | None = None,
+        attach_at_mm: tuple[float, float] | None = None,
+        dimension: tuple[str, str] | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Add a GD&T feature control frame to the active drawing.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_gtol is not implemented by this adapter",
+        )
+
+    async def add_datum_tag(
+        self,
+        label: str,
+        attach_at_mm: tuple[float, float],
+        x_mm: float,
+        y_mm: float,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Add a datum feature symbol on a drawing edge.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="add_datum_tag is not implemented by this adapter",
+        )
+
+    async def create_standard_drawing(
+        self,
+        model_path: str,
+        output_dir: str | None = None,
+        title: str | None = None,
+        subtitle: str | None = None,
+        drawing_number: str | None = None,
+        author: str = "",
+        revision: str = "A",
+        company: str = "",
+        drawn_date: str | None = None,
+        notes: list[str] | None = None,
+        include_isometric: bool = True,
+        write_model_properties: bool = True,
+        title_block_text_height_mm: float | None = None,
+        include_bom: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Create a complete standard A3 drawing.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Error unless the adapter implements it.
+        """
+        return AdapterResult(
+            status=AdapterResultStatus.ERROR,
+            error="create_standard_drawing is not implemented by this adapter",
+        )