inventor_mcp_server.py

"""
Inventor MCP Server
====================
Ein minimaler Model-Context-Protocol-Server, der Autodesk Inventor
ueber die COM-API fernsteuert. Gedacht als Ausgangspunkt zum Erweitern.

Voraussetzungen (nur Windows):
    - Autodesk Inventor installiert und GEOEFFNET
    - pip install "mcp[cli]" pywin32

Start zum Testen:
    python inventor_mcp_server.py
oder mit dem MCP-Inspector:
    npx @modelcontextprotocol/inspector python inventor_mcp_server.py

Einbindung in Claude Desktop (claude_desktop_config.json):
    {
      "mcpServers": {
        "inventor-mcp": {
          "command": "python",
          "args": ["C:/pfad/zu/inventor_mcp_server.py"]
        }
      }
    }

Wichtige Hinweise:
    - Inventor rechnet intern in ZENTIMETERN. Alle Tools nehmen mm entgegen
      und rechnen intern um (mm / 10 = cm).
    - Ein Vorgang pro Tool-Aufruf. Kein Batching -> sonst Absturzgefahr.
    - COM ist nicht thread-sicher: alle Zugriffe laufen ueber denselben Thread.
"""

from __future__ import annotations

import math
import sys
import uuid

# --- MCP SDK ---------------------------------------------------------------
try:
    from mcp.server.fastmcp import FastMCP
except ImportError:
    sys.stderr.write(
        "Fehlt: MCP-SDK. Installiere mit:  pip install \"mcp[cli]\"\n"
    )
    raise

# --- Inventor COM (nur auf Windows verfuegbar) -----------------------------
try:
    import pythoncom  # type: ignore
    import win32com.client  # type: ignore
    import win32com.client.gencache  # type: ignore
    _HAS_WIN32 = True
except ImportError:
    # Erlaubt Import/Syntaxpruefung auf Nicht-Windows-Systemen.
    _HAS_WIN32 = False

# Modulweiter Cache fuer das per gencache erzeugte Konstanten-Modul.
# Wird erst in _get_app() befuellt, weil dafuer eine laufende COM-Verbindung
# noetig ist. WICHTIG: Wir raten hier KEINE Enum-Zahlen mehr (z.B.
# kNewBodyOperation, kPositiveExtentDirection). Stattdessen liest gencache
# die echten Werte direkt aus Inventors Typbibliothek. Das vermeidet genau
# die Klasse von Fehlern, die vorher zu 'DISP_E_EXCEPTION' gefuehrt hat.
_const = None


mcp = FastMCP("inventor-mcp")

# Modulweiter Cache der Inventor-Applikationsinstanz.
_app = None


# ---------------------------------------------------------------------------
# Interne Hilfsfunktionen
# ---------------------------------------------------------------------------
def _mm_to_cm(value_mm: float) -> float:
    """Inventor-interne Einheit ist cm."""
    return value_mm / 10.0


def _parse_feature_operation(operation: str):
    """Return an Inventor operation enum and reject ambiguous input.

    Older tools silently converted every misspelling to ``new``.  That is
    dangerous for destructive operations such as a sweep cut, so the newer
    feature tools share this strict parser.
    """
    normalized = str(operation).strip().lower()
    operations = {
        "new": _const.kNewBodyOperation,
        "join": _const.kJoinOperation,
        "cut": _const.kCutOperation,
        "intersect": _const.kIntersectOperation,
        "surface": _const.kSurfaceOperation,
    }
    if normalized not in operations:
        raise ValueError(
            f"Unknown operation '{operation}'. Allowed values: "
            "new, join, cut, intersect, surface."
        )
    return operations[normalized]


def _parse_3d_point_string(points: str, minimum: int = 2) -> list[tuple[float, float, float]]:
    """Parse ``x,y,z;x,y,z`` millimetre coordinates and validate the path."""
    parsed: list[tuple[float, float, float]] = []
    for raw_point in (part.strip() for part in str(points).split(";")):
        if not raw_point:
            continue
        coordinates = [value.strip() for value in raw_point.split(",")]
        if len(coordinates) != 3:
            raise ValueError(
                f"Invalid 3D point '{raw_point}'. Expected 'x,y,z' in mm."
            )
        try:
            point = tuple(float(value) for value in coordinates)
        except ValueError as exc:
            raise ValueError(
                f"Invalid 3D point '{raw_point}': coordinates must be numbers."
            ) from exc
        if not all(math.isfinite(value) for value in point):
            raise ValueError(f"Invalid 3D point '{raw_point}': values must be finite.")
        if parsed and all(
            abs(point[index] - parsed[-1][index]) < 1e-9 for index in range(3)
        ):
            raise ValueError(
                f"Consecutive path points must differ; '{raw_point}' is duplicated."
            )
        parsed.append(point)

    if len(parsed) < minimum:
        raise ValueError(f"At least {minimum} 3D points are required.")
    return parsed


def _normal_plane_axes(
    start: tuple[float, float, float],
    end: tuple[float, float, float],
) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
    """Build stable, right-handed X/Y axes for a plane normal to a segment."""
    normal = tuple(end[index] - start[index] for index in range(3))
    length = math.sqrt(sum(value * value for value in normal))
    if length < 1e-12:
        raise ValueError("The first sweep path segment has zero length.")
    normal = tuple(value / length for value in normal)

    # Choose a reference axis that is not almost parallel to the path.
    reference = (0.0, 0.0, 1.0) if abs(normal[2]) < 0.9 else (0.0, 1.0, 0.0)
    x_axis = (
        reference[1] * normal[2] - reference[2] * normal[1],
        reference[2] * normal[0] - reference[0] * normal[2],
        reference[0] * normal[1] - reference[1] * normal[0],
    )
    x_length = math.sqrt(sum(value * value for value in x_axis))
    x_axis = tuple(value / x_length for value in x_axis)
    y_axis = (
        normal[1] * x_axis[2] - normal[2] * x_axis[1],
        normal[2] * x_axis[0] - normal[0] * x_axis[2],
        normal[0] * x_axis[1] - normal[1] * x_axis[0],
    )
    return x_axis, y_axis


def _parse_loft_sections(sections: str) -> list[dict]:
    """Parse legacy circular and structured circle/rectangle loft sections.

    Legacy format: ``plane:diameter`` (for example ``XY:50;30:40``).
    Structured format uses pipes so offset planes remain unambiguous:
    ``plane|circle|diameter|cx|cy`` or
    ``plane|rectangle|width|height|cx|cy``.  Centres default to zero.
    """
    result: list[dict] = []
    for raw_section in (part.strip() for part in str(sections).split(";")):
        if not raw_section:
            continue
        if "|" not in raw_section:
            legacy = [value.strip() for value in raw_section.split(":")]
            if len(legacy) != 2:
                raise ValueError(
                    f"Invalid loft section '{raw_section}'. Expected "
                    "'plane:diameter' or the structured pipe format."
                )
            plane, diameter = legacy
            values = {
                "plane": plane,
                "shape": "circle",
                "diameter_mm": float(diameter),
                "center_x_mm": 0.0,
                "center_y_mm": 0.0,
            }
        else:
            fields = [value.strip() for value in raw_section.split("|")]
            if len(fields) < 3:
                raise ValueError(f"Invalid structured loft section '{raw_section}'.")
            plane, shape = fields[0], fields[1].lower()
            if shape == "circle" and len(fields) in (3, 5):
                values = {
                    "plane": plane,
                    "shape": shape,
                    "diameter_mm": float(fields[2]),
                    "center_x_mm": float(fields[3]) if len(fields) == 5 else 0.0,
                    "center_y_mm": float(fields[4]) if len(fields) == 5 else 0.0,
                }
            elif shape in ("rectangle", "rect") and len(fields) in (4, 6):
                values = {
                    "plane": plane,
                    "shape": "rectangle",
                    "width_mm": float(fields[2]),
                    "height_mm": float(fields[3]),
                    "center_x_mm": float(fields[4]) if len(fields) == 6 else 0.0,
                    "center_y_mm": float(fields[5]) if len(fields) == 6 else 0.0,
                }
            else:
                raise ValueError(
                    f"Invalid loft section '{raw_section}'. Use "
                    "plane|circle|diameter[|cx|cy] or "
                    "plane|rectangle|width|height[|cx|cy]."
                )

        dimensions = [
            value for key, value in values.items()
            if key in ("diameter_mm", "width_mm", "height_mm")
        ]
        if not values["plane"]:
            raise ValueError("Every loft section needs a plane.")
        if not all(math.isfinite(float(value)) and float(value) > 0 for value in dimensions):
            raise ValueError(f"Loft section dimensions must be finite and greater than zero: '{raw_section}'.")
        if not all(
            math.isfinite(float(values[key]))
            for key in ("center_x_mm", "center_y_mm")
        ):
            raise ValueError(f"Loft section centres must be finite: '{raw_section}'.")
        result.append(values)

    if len(result) < 2:
        raise ValueError("At least two loft sections are required.")
    return result


def _detect_cut_direction(comp_def):
    """
    Erkennt die Richtung des ersten Volumenkoerpers anhand der Bounding-Box
    und liefert die passende ExtendDirection-Konstante fuer Schnitte/Bohrungen,
    die von der XY-Ebene aus gehen.

    Rueckgabe:
        kNegativeExtentDirection  wenn der Koerper ueberwiegend in Z+ liegt
                                  (Schnitt muss nach unten gehen)
        kPositiveExtentDirection  wenn der Koerper ueberwiegend in Z- liegt
                                  (Schnitt muss nach oben gehen)
        kSymmetricExtentDirection wenn der Koerper beidseitig liegt
    """
    if comp_def.SurfaceBodies.Count == 0:
        return _const.kNegativeExtentDirection

    body = comp_def.SurfaceBodies.Item(1)
    try:
        Box = body.RangeBox
        z_min = Box.MinPoint.Z
        z_max = Box.MaxPoint.Z
    except Exception:
        return _const.kNegativeExtentDirection

    tol = 1e-6
    if z_min >= -tol and z_max > tol:
        # Koerper liegt ueberwiegend in Z+ (typisch: direction="positive")
        return _const.kNegativeExtentDirection
    elif z_max <= tol and z_min < -tol:
        # Koerper liegt ueberwiegend in Z- (typisch: direction="negative")
        return _const.kPositiveExtentDirection
    elif z_min < -tol and z_max > tol:
        # Koerper beidseitig (typisch: direction="symmetric")
        return _const.kSymmetricExtentDirection
    else:
        # Koerper liegt auf Z=0 oder ist sehr flach
        return _const.kNegativeExtentDirection


def _resolve_work_plane(comp_def, plane: str):
    """
    Loest eine Ebenen-Angabe in ein WorkPlane-Objekt auf.
    Unterstuetzt:
      - "XY", "XZ", "YZ" (Standard-Ebenen)
      - "XZ:30" (Ebene mit Offset in mm von der Basisebene)
      - "Work Plane1" (benannte Ebene)
    """
    plane = plane.strip()
    if ":" in plane:
        parts = plane.split(":", 1)
        base = parts[0].strip().upper()
        offset_mm = float(parts[1].strip())
        base_map = {"XY": 3, "XZ": 2, "YZ": 1}
        if base not in base_map:
            raise ValueError(f"Unbekannte Basisebene: '{base}'. Erlaubt: XY, XZ, YZ.")
        return comp_def.WorkPlanes.AddByPlaneAndOffset(
            comp_def.WorkPlanes.Item(base_map[base]),
            _mm_to_cm(offset_mm),
        )

    plane_upper = plane.upper()
    if plane_upper in ("XY", "XZ", "YZ"):
        base_map = {"XY": 3, "XZ": 2, "YZ": 1}
        return comp_def.WorkPlanes.Item(base_map[plane_upper])

    # Als benannte Ebene versuchen.
    try:
        return comp_def.WorkPlanes.Item(plane)
    except Exception:
        raise ValueError(
            f"Ebene '{plane}' nicht erkannt. "
            "Erlaubt: 'XY', 'XZ', 'YZ', 'XZ:30' (Offset), 'Work Plane1'."
        )


def _get_app():
    """
    Verbindet sich mit einer laufenden Inventor-Instanz und sorgt dafuer,
    dass win32com.client.constants mit den ECHTEN Enum-Werten aus Inventors
    Typbibliothek befuellt wird (frueher Bindung / gencache).
    Faellt zurueck auf das Starten einer neuen Instanz, falls keine laeuft.
    """
    global _app, _const
    if not _HAS_WIN32:
        raise RuntimeError(
            "pywin32 nicht verfuegbar - dieser Server laeuft nur auf Windows."
        )

    if _app is not None:
        return _app

    pythoncom.CoInitialize()
    try:
        # Bereits laufende Instanz bevorzugen, aber ueber gencache binden,
        # damit die Typbibliothek (und damit die Konstanten) geladen wird.
        _app = win32com.client.gencache.EnsureDispatch("Inventor.Application")
    except pythoncom.com_error:
        # Keine laufende Instanz gefunden -> neu starten.
        _app = win32com.client.gencache.EnsureDispatch("Inventor.Application")
        _app.Visible = True

    # win32com.client.constants wird durch EnsureDispatch global befuellt.
    _const = win32com.client.constants
    return _app


def _require_part_document(app):
    """
    Stellt sicher, dass das aktive Dokument ein Bauteil (Part) ist, UND
    castet es explizit auf PartDocument.

    Grund: app.ActiveDocument liefert bei frueher Bindung (gencache) ein
    generisches 'Document'-Objekt zurueck. Nur ein 'PartDocument' hat die
    Eigenschaft 'ComponentDefinition'. Ohne diesen Cast schlaegt jeder
    Zugriff auf ComponentDefinition mit
    "'...Document instance...' object has no attribute 'ComponentDefinition'"
    fehl.
    """
    doc = app.ActiveDocument
    if doc is None:
        raise RuntimeError("Kein aktives Dokument in Inventor geoeffnet.")
    if doc.DocumentType != _const.kPartDocumentObject:
        raise RuntimeError(
            "Aktives Dokument ist kein Bauteil (Part). "
            "Bitte zuerst 'create_part' aufrufen oder ein .ipt oeffnen."
        )
    # Expliziter Cast auf PartDocument - das behebt den fehlenden Zugriff
    # auf ComponentDefinition.
    part_doc = win32com.client.CastTo(doc, "PartDocument")
    if part_doc is None:
        raise RuntimeError(
            "Cast auf PartDocument fehlgeschlagen. Moeglicherweise ist die "
            "gencache-Typbibliothek veraltet - Ordner "
            "%TEMP%/gen_py loeschen und Inventor/Skript neu starten."
        )
    return part_doc


def _get_translator(app, *keywords):
    """
    Sucht ein Uebersetzer-Add-in ueber seinen Anzeigenamen, statt eine fest
    verdrahtete CLSID zu verwenden. Robuster, weil GUIDs zwischen Versionen
    abweichen koennen. 'keywords' sind Teilstrings, die alle (case-insensitiv)
    im Namen vorkommen muessen, z. B. _get_translator(app, "STL").
    """
    keywords_low = [k.lower() for k in keywords]
    for addin in app.ApplicationAddIns:
        try:
            name = (addin.DisplayName or "").lower()
        except Exception:
            continue
        if all(k in name for k in keywords_low):
            return _cast_translator(addin)
    raise RuntimeError(
        "Kein passendes Uebersetzer-Add-in gefunden fuer: "
        + ", ".join(keywords)
    )


def _cast_translator(addin):
    """
    Castet ein generisches ApplicationAddIn auf TranslatorAddIn.
    Noetig, weil das generische Objekt (z.B. aus einer Iteration ueber
    app.ApplicationAddIns oder aus ItemById) keine SaveCopyAs-Methode hat -
    die existiert nur auf dem TranslatorAddIn-Interface. Gleiche Fehler-
    klasse wie beim PartDocument-Cast weiter oben.
    """
    translator = win32com.client.CastTo(addin, "TranslatorAddIn")
    if translator is None:
        raise RuntimeError(
            "Cast auf TranslatorAddIn fehlgeschlagen fuer Add-in "
            f"'{getattr(addin, 'DisplayName', '?')}'."
        )
    return translator


def _export_via_translator(app, doc, addin, file_path):
    """Gemeinsame Export-Logik fuer Translator-Add-ins (STEP/STL/DXF ...)."""
    context = app.TransientObjects.CreateTranslationContext()
    context.Type = _const.kFileBrowseIOMechanism
    options = app.TransientObjects.CreateNameValueMap()
    data_medium = app.TransientObjects.CreateDataMedium()
    data_medium.FileName = file_path
    addin.SaveCopyAs(doc, context, options, data_medium)


def _all_edges(app, comp_def):
    """
    Sammelt alle Kanten des ersten Volumenkoerpers in einer EdgeCollection.
    Genutzt von Fillet/Chamfer, da wir keine interaktive Kantenauswahl haben.
    """
    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError(
            "Kein Volumenkoerper vorhanden. Erst z. B. 'create_box' aufrufen."
        )
    body = comp_def.SurfaceBodies.Item(1)
    edge_coll = app.TransientObjects.CreateEdgeCollection()
    for edge in body.Edges:
        edge_coll.Add(edge)
    return edge_coll


def _filtered_edges(app, comp_def, which):
    """
    Liefert eine EdgeCollection, gefiltert nach Lage (statt interaktiver
    Auswahl). 'which' ist eines von:
        "all"      - alle Kanten
        "top"      - nur Kanten ganz oben (max Z)
        "bottom"   - nur Kanten ganz unten (min Z)
        "vertical" - nur senkrechte Kanten (Z aendert sich entlang der Kante)

    Filtert ueber die Z-Koordinaten der Kanten-Endpunkte. Gekruemmte Kanten
    ohne Endpunkte (z. B. volle Kreise) landen nur bei "all".
    """
    which = (which or "all").lower()
    if which == "all":
        return _all_edges(app, comp_def)

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError(
            "Kein Volumenkoerper vorhanden. Erst z. B. 'create_box' aufrufen."
        )
    body = comp_def.SurfaceBodies.Item(1)

    def _z_range(edge):
        """(z_start, z_stop) oder None, falls keine Endpunkte vorhanden."""
        try:
            z1 = edge.StartVertex.Point.Z
            z2 = edge.StopVertex.Point.Z
            return z1, z2
        except Exception:
            return None

    tol = 1e-4
    zs = []
    for edge in body.Edges:
        zr = _z_range(edge)
        if zr:
            zs.extend(zr)
    if not zs:
        raise RuntimeError(
            "Keine geraden Kanten mit Endpunkten gefunden - fuer diesen "
            "Koerper ist nur 'all' moeglich."
        )
    z_max, z_min = max(zs), min(zs)

    coll = app.TransientObjects.CreateEdgeCollection()
    for edge in body.Edges:
        zr = _z_range(edge)
        if zr is None:
            continue
        z1, z2 = zr
        if which == "top" and abs(z1 - z_max) < tol and abs(z2 - z_max) < tol:
            coll.Add(edge)
        elif which == "bottom" and abs(z1 - z_min) < tol and abs(z2 - z_min) < tol:
            coll.Add(edge)
        elif which == "vertical" and abs(z1 - z2) > tol:
            coll.Add(edge)

    if coll.Count == 0:
        raise RuntimeError(
            f"Keine Kanten fuer Filter '{which}' gefunden."
        )
    return coll


# ---------------------------------------------------------------------------
# Skizzen-Bestimmung: Bemassungen (DimensionConstraints) und geometrische
# Abhaengigkeiten (GeometricConstraints), damit Skizzen VOLL BESTIMMT sind.
# ---------------------------------------------------------------------------
def _project_origin(sketch, comp_def):
    """
    Projiziert den Modell-Ursprung (WorkPoints.Item(1)) in die Skizze und
    liefert den zugehoerigen SketchPoint.

    WICHTIG: Wir nutzen NICHT den Rueckgabewert von AddByProjectingEntity
    direkt (der ist ein generisches COM-Objekt und mehrfacher Cast-Versuch
    darauf schlug fehl). Stattdessen rufen wir die Methode nur fuer ihren
    Seiteneffekt auf und holen den neu erzeugten Punkt danach aus der
    sketch.SketchPoints-Collection - die ist stark typisiert und liefert
    direkt einen echten SketchPoint, ganz ohne Cast. Gleiches Muster wie in
    den offiziellen Autodesk-Beispielen (Punkt wird ueber SketchPoints.Item
    nach dem Projizieren abgeholt, nicht ueber den Rueckgabewert).
    """
    origin_wp = comp_def.WorkPoints.Item(1)
    count_before = sketch.SketchPoints.Count
    sketch.AddByProjectingEntity(origin_wp)
    count_after = sketch.SketchPoints.Count

    if count_after > count_before:
        # Neuer Punkt wurde angehaengt - das ist unser Ursprungspunkt.
        return sketch.SketchPoints.Item(count_after)

    # Fallback: nach ReferencedEntity suchen (z. B. falls der Punkt schon
    # vorher projiziert war und kein neuer entstand).
    for sp in sketch.SketchPoints:
        try:
            if sp.ReferencedEntity is not None:
                return sp
        except Exception:
            continue

    raise RuntimeError("Projizierter Ursprungspunkt nicht gefunden.")


def _as_sketch_line(entity):
    """
    Castet ein generisches SketchEntity (z.B. aus einer
    SketchEntitiesEnumerator wie dem Rueckgabewert von
    AddAsTwoPointRectangle) auf SketchLine. Noetig, weil das generische
    Objekt keine StartSketchPoint/EndSketchPoint-Eigenschaften hat - gleiche
    Fehlerklasse wie beim PartDocument- und TranslatorAddIn-Cast.
    """
    line = win32com.client.CastTo(entity, "SketchLine")
    if line is None:
        raise RuntimeError("Cast auf SketchLine fehlgeschlagen.")
    return line


def _nearest_sketch_point(rect_lines, x_cm, y_cm, tol=1e-6):
    """Sucht unter den Eckpunkten der Rechteck-Linien den Punkt, der (x,y)
    am naechsten liegt."""
    best, best_d = None, None
    for i in range(1, rect_lines.Count + 1):
        line = _as_sketch_line(rect_lines.Item(i))
        for sp in (line.StartSketchPoint, line.EndSketchPoint):
            g = sp.Geometry
            d = (g.X - x_cm) ** 2 + (g.Y - y_cm) ** 2
            if best_d is None or d < best_d:
                best_d, best = d, sp
    return best


def _points_already_merged(p1, p2, tol=1e-6):
    """
    Prueft, ob zwei SketchPoints geometrisch identisch sind. Inventor
    verschmilzt einen projizierten Ursprungspunkt automatisch mit einem
    bereits vorhandenen Skizzenpunkt an derselben Stelle - dann sind beide
    de facto derselbe Punkt, und eine explizite Koinzidenz-Bedingung
    zwischen ihnen ist ungueltig (E_INVALIDARG) und unnoetig.
    """
    try:
        return (
            abs(p1.Geometry.X - p2.Geometry.X) < tol
            and abs(p1.Geometry.Y - p2.Geometry.Y) < tol
        )
    except Exception:
        return False


def _try_step(beschreibung, fn):
    """
    Fuehrt einen einzelnen Constrain-Schritt aus und haengt bei einem Fehler
    die Beschreibung an, damit wir in der Rueckmeldung sehen, welcher
    Teilschritt (Ursprung projizieren, Bemassung X, Bemassung Y, ...)
    fehlgeschlagen ist - statt nur eines nichtssagenden COM-Fehlercodes.
    """
    try:
        return fn()
    except Exception as exc:
        raise RuntimeError(f"[{beschreibung}] {exc}") from exc


def _constrain_rectangle(app, sketch, comp_def, rect_lines,
                         x_cm, y_cm, w_cm, h_cm):
    """
    Versucht, ein Rechteck voll zu bestimmen: Lage der unteren linken Ecke
    (Koinzidenz zum Ursprung bei Offset 0, sonst Bemassung) plus Breite/Hoehe.
    Rueckgabe: "voll" oder "teilweise" (Best-Effort, Geometrie bleibt intakt).
    """
    tg = app.TransientGeometry
    geo = sketch.GeometricConstraints
    dim = sketch.DimensionConstraints

    origin_sp = _try_step(
        "Ursprung projizieren", lambda: _project_origin(sketch, comp_def)
    )
    corner = _try_step(
        "Eckpunkt suchen",
        lambda: _nearest_sketch_point(rect_lines, x_cm, y_cm),
    )
    at_origin = abs(x_cm) < 1e-6 and abs(y_cm) < 1e-6

    status = "voll"

    # --- Lage fixieren ---
    if at_origin:
        def _do_coincident():
            if _points_already_merged(corner, origin_sp):
                return  # Bereits durch Verschmelzung fixiert - nichts zu tun.
            try:
                geo.AddCoincident(corner, origin_sp)
            except Exception as exc:
                raise RuntimeError(
                    f"{exc!r} | corner_pytype={type(corner).__name__} "
                    f"origin_pytype={type(origin_sp).__name__}"
                ) from exc

        _try_step("Koinzidenz Ecke-Ursprung", _do_coincident)
    else:
        # Position ueber Bemassung vom Ursprung; Null-Offsets lassen 1 DOF
        # offen -> dann "teilweise".
        if abs(x_cm) > 1e-6:
            _try_step(
                "Bemassung X-Position",
                lambda: dim.AddTwoPointDistance(
                    origin_sp, corner, _const.kHorizontalDim,
                    tg.CreatePoint2d(x_cm / 2.0, y_cm - 0.5),
                ),
            )
        else:
            status = "teilweise"
        if abs(y_cm) > 1e-6:
            _try_step(
                "Bemassung Y-Position",
                lambda: dim.AddTwoPointDistance(
                    origin_sp, corner, _const.kVerticalDim,
                    tg.CreatePoint2d(x_cm - 0.5, y_cm / 2.0),
                ),
            )
        else:
            status = "teilweise"

    # --- Groesse bemassen (Breite + Hoehe) ---
    # Untere Kante (horizontal) und eine Seitenkante (vertikal) finden.
    horiz_line = vert_line = None
    for i in range(1, rect_lines.Count + 1):
        line = _as_sketch_line(rect_lines.Item(i))
        p1, p2 = line.StartSketchPoint.Geometry, line.EndSketchPoint.Geometry
        if abs(p1.Y - p2.Y) < 1e-6 and horiz_line is None:
            horiz_line = line
        elif abs(p1.X - p2.X) < 1e-6 and vert_line is None:
            vert_line = line

    if horiz_line is not None:
        _try_step(
            "Bemassung Breite",
            lambda: dim.AddTwoPointDistance(
                horiz_line.StartSketchPoint, horiz_line.EndSketchPoint,
                _const.kHorizontalDim,
                tg.CreatePoint2d(x_cm + w_cm / 2.0, y_cm - 1.0),
            ),
        )
    else:
        status = "teilweise"
    if vert_line is not None:
        _try_step(
            "Bemassung Hoehe",
            lambda: dim.AddTwoPointDistance(
                vert_line.StartSketchPoint, vert_line.EndSketchPoint,
                _const.kVerticalDim,
                tg.CreatePoint2d(x_cm - 1.0, y_cm + h_cm / 2.0),
            ),
        )
    else:
        status = "teilweise"

    return status


def _constrain_circle(app, sketch, comp_def, circle, cx_cm, cy_cm, diameter_cm):
    """
    Versucht, einen Kreis voll zu bestimmen: Mittelpunktlage + Durchmesser.
    Rueckgabe: "voll" oder "teilweise".
    """
    tg = app.TransientGeometry
    geo = sketch.GeometricConstraints
    dim = sketch.DimensionConstraints

    origin_sp = _try_step(
        "Ursprung projizieren", lambda: _project_origin(sketch, comp_def)
    )
    center = circle.CenterSketchPoint
    status = "voll"

    if abs(cx_cm) < 1e-6 and abs(cy_cm) < 1e-6:
        def _do_coincident_circle():
            if _points_already_merged(center, origin_sp):
                return
            geo.AddCoincident(center, origin_sp)

        _try_step("Koinzidenz Mittelpunkt-Ursprung", _do_coincident_circle)
    else:
        if abs(cx_cm) > 1e-6:
            _try_step(
                "Bemassung X-Position",
                lambda: dim.AddTwoPointDistance(
                    origin_sp, center, _const.kHorizontalDim,
                    tg.CreatePoint2d(cx_cm / 2.0, cy_cm - 0.5),
                ),
            )
        else:
            status = "teilweise"
        if abs(cy_cm) > 1e-6:
            _try_step(
                "Bemassung Y-Position",
                lambda: dim.AddTwoPointDistance(
                    origin_sp, center, _const.kVerticalDim,
                    tg.CreatePoint2d(cx_cm - 0.5, cy_cm / 2.0),
                ),
            )
        else:
            status = "teilweise"

    _try_step(
        "Bemassung Durchmesser",
        lambda: dim.AddDiameter(
            circle, tg.CreatePoint2d(cx_cm + diameter_cm, cy_cm)
        ),
    )
    return status


def _safe_constrain(fn):
    """
    Fuehrt eine Constrain-Funktion aus, ohne dass ein Fehler die Geometrie-
    Erzeugung stoppt. Rueckgabe: Statuswort fuer die Nutzer-Rueckmeldung.
    """
    try:
        return fn()
    except Exception as exc:  # bewusst breit: Bemassen ist Best-Effort
        return f"nicht bestimmt ({exc})"


# ---------------------------------------------------------------------------
# Stabile Geometrie-Handles
# ---------------------------------------------------------------------------
_GEOMETRY_ATTRIBUTE_SET = "CustomMcpGeometry"
_GEOMETRY_ATTRIBUTE = "GeometryId"


def _get_geometry_id(entity, prefix: str) -> str:
    """Liest oder vergibt eine persistente ID auf einer Inventor-Entitaet.

    AttributeSets werden von Inventor an der jeweiligen Face/Edge gespeichert
    und sind dadurch deutlich robuster als die laufenden Collection-Indizes.
    Bei Topologie-Neuberechnung kann Inventor Attribute trotzdem verwerfen;
    der Aufrufer sollte in diesem Fall die Faces erneut auflisten.
    """
    try:
        sets = entity.AttributeSets
        for i in range(1, sets.Count + 1):
            attr_set = sets.Item(i)
            if attr_set.Name != _GEOMETRY_ATTRIBUTE_SET:
                continue
            try:
                return str(attr_set.Item(_GEOMETRY_ATTRIBUTE).Value)
            except Exception:
                break

        attr_set = sets.Add(_GEOMETRY_ATTRIBUTE_SET)
        value = f"{prefix}_{uuid.uuid4().hex}"
        attr_set.Add(_GEOMETRY_ATTRIBUTE, _const.kStringType, value)
        return value
    except Exception as exc:
        raise RuntimeError(
            "Inventor konnte keinen stabilen Geometrie-Handle speichern. "
            f"Entitaet ist moeglicherweise nicht attributierbar: {exc}"
        ) from exc


def _find_face_by_geometry_id(body, geometry_id: str):
    for i in range(1, body.Faces.Count + 1):
        face = body.Faces.Item(i)
        try:
            if _get_geometry_id(face, "face") == geometry_id:
                return face
        except Exception:
            continue
    return None


def _find_edge_by_geometry_id(body, geometry_id: str):
    for i in range(1, body.Edges.Count + 1):
        edge = body.Edges.Item(i)
        try:
            if _get_geometry_id(edge, "edge") == geometry_id:
                return edge
        except Exception:
            continue
    return None


def _resolve_face_reference(body, reference: str):
    """Loest eine stabile Face-ID auf; numerische Indizes bleiben legacy."""
    reference = str(reference).strip()
    if reference.isdigit():
        index = int(reference)
        if index < 1 or index > body.Faces.Count:
            raise ValueError(f"Flaechen-Index {index} ungueltig.")
        return body.Faces.Item(index), "legacy-index"
    face = _find_face_by_geometry_id(body, reference)
    if face is None:
        raise ValueError(f"Flaechen-ID '{reference}' nicht gefunden.")
    return face, "geometry-id"


def _resolve_edge_reference(body, reference: str):
    """Loest eine stabile Edge-ID auf; numerische Indizes bleiben legacy."""
    reference = str(reference).strip()
    if reference.isdigit():
        index = int(reference)
        if index < 1 or index > body.Edges.Count:
            raise ValueError(f"Kanten-Index {index} ungueltig.")
        return body.Edges.Item(index), "legacy-index"
    edge = _find_edge_by_geometry_id(body, reference)
    if edge is None:
        raise ValueError(f"Kanten-ID '{reference}' nicht gefunden.")
    return edge, "geometry-id"


def _build_face_collection(app, comp_def, face_specs: str):
    """Build a FaceCollection from stable IDs or legacy body-face indices."""
    body = comp_def.SurfaceBodies.Item(1)
    collection = app.TransientObjects.CreateFaceCollection()
    references = [part.strip() for part in str(face_specs).split(",") if part.strip()]
    seen: set[str] = set()
    for reference in references:
        face, _ = _resolve_face_reference(body, reference)
        geometry_id = _get_geometry_id(face, "face")
        if geometry_id in seen:
            continue
        collection.Add(face)
        seen.add(geometry_id)
    return collection


def _resolve_chamfer_face(body, edges, reference_face: str):
    """Resolve or infer the face from which an asymmetric chamfer is measured."""
    first_edge = edges.Item(1)
    if str(reference_face).strip():
        face, reference_kind = _resolve_face_reference(body, reference_face)
    else:
        try:
            face = first_edge.Faces.Item(1)
        except Exception as exc:
            raise RuntimeError(
                "Could not infer the chamfer reference face. Pass reference_face "
                "using a geometry_id returned by list_faces."
            ) from exc
        reference_kind = "inferred"

    first_edge_id = _get_geometry_id(first_edge, "edge")
    belongs_to_face = any(
        _get_geometry_id(face.Edges.Item(index), "edge") == first_edge_id
        for index in range(1, face.Edges.Count + 1)
    )
    if not belongs_to_face:
        raise ValueError("The first selected edge does not belong to reference_face.")
    return face, reference_kind


# ---------------------------------------------------------------------------
# MCP-Tools
# ---------------------------------------------------------------------------
@mcp.tool()
def ping() -> str:
    """Prueft die Verbindung zu Inventor und gibt die Version zurueck."""
    app = _get_app()
    return f"Verbunden mit Inventor {app.SoftwareVersion.DisplayName}"


@mcp.tool()
def create_part(name: str = "Bauteil1") -> str:
    """
    Erstellt ein neues, leeres Bauteil-Dokument (.ipt) und macht es aktiv.

    Args:
        name: Anzeigename des neuen Bauteils.
    """
    app = _get_app()
    doc_type = _const.kPartDocumentObject
    template = app.FileManager.GetTemplateFile(doc_type)
    doc = app.Documents.Add(doc_type, template, True)
    try:
        doc.DisplayName = name
    except Exception:
        pass  # DisplayName ist nicht immer setzbar vor dem Speichern.
    return f"Neues Bauteil '{name}' erstellt."


@mcp.tool()
def create_box(
    length_mm: float,
    width_mm: float,
    height_mm: float,
    direction: str = "positive",
) -> str:
    """
    Erstellt eine rechteckige Box durch Skizze auf der XY-Ebene + Extrusion.

    Args:
        length_mm: Laenge in X-Richtung (mm).
        width_mm:  Breite in Y-Richtung (mm).
        height_mm: Hoehe der Extrusion in Z-Richtung (mm).
        direction: Extrusionsrichtung: "positive" (Z+, Standard),
                   "negative" (Z-), "symmetric" (zentriert).
    """
    if min(length_mm, width_mm, height_mm) <= 0:
        raise ValueError("Alle Masse muessen groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    # Dokument explizit aktivieren - vermeidet Faelle, in denen ein anderes
    # Fenster/Dokument in Inventor gerade im Vordergrund ist.
    doc.Activate()

    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    length = _mm_to_cm(length_mm)
    width = _mm_to_cm(width_mm)
    height = _mm_to_cm(height_mm)

    def _step(beschreibung, fn):
        """Fuehrt einen einzelnen COM-Aufruf aus und gibt bei Fehlern
        genau an, in welchem Schritt es geknallt hat - statt eines
        nichtssagenden generischen COM-Fehlers."""
        try:
            return fn()
        except pythoncom.com_error as exc:
            raise RuntimeError(
                f"Fehler bei Schritt '{beschreibung}': {exc}"
            ) from exc

    # Skizze auf der XY-Ebene (WorkPlanes.Item(3) entspricht in den
    # offiziellen Autodesk-Beispielen durchgaengig der XY-Basisebene).
    sketch = _step(
        "Skizze anlegen",
        lambda: comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3)),
    )

    # Rechteck ueber zwei Diagonalpunkte.
    p1 = tg.CreatePoint2d(0, 0)
    p2 = tg.CreatePoint2d(length, width)
    rect_lines = _step(
        "Rechteck zeichnen",
        lambda: sketch.SketchLines.AddAsTwoPointRectangle(p1, p2),
    )

    # Skizze voll bestimmen (Bemassung + Abhaengigkeiten).
    constrain_status = _safe_constrain(
        lambda: _constrain_rectangle(
            app, sketch, comp_def, rect_lines, 0, 0, length, width
        )
    )

    # Profil aus der geschlossenen Skizze.
    profile = _step("Profil erzeugen", lambda: sketch.Profiles.AddForSolid())

    # Extrusionsdefinition: neuer Koerper, Distanz = height.
    # _const liefert die ECHTEN Werte aus Inventors Typbibliothek statt
    # geratener Zahlen.
    ext_def = _step(
        "Extrusionsdefinition erzeugen",
        lambda: comp_def.Features.ExtrudeFeatures.CreateExtrudeDefinition(
            profile, _const.kNewBodyOperation
        ),
    )
    dir_enum = _parse_direction(direction)
    _step(
        "Extrusionsdistanz setzen",
        lambda: ext_def.SetDistanceExtent(height, dir_enum),
    )
    _step(
        "Extrusion ausfuehren",
        lambda: comp_def.Features.ExtrudeFeatures.Add(ext_def),
    )

    _rename_box_params(comp_def, length_mm, width_mm, height_mm)

    return (
        f"Box erstellt: {length_mm} x {width_mm} x {height_mm} mm "
        f"(L x B x H), Richtung '{direction}'. Skizze: {constrain_status} bestimmt."
    )


@mcp.tool()
def export_step(file_path: str) -> str:
    """
    Exportiert das aktive Bauteil als STEP-Datei.

    Args:
        file_path: Vollstaendiger Zielpfad, z. B. C:/temp/teil.step
    """
    app = _get_app()
    doc = _require_part_document(app)

    # Erst ueber den Namen suchen (robust), sonst per bekannter CLSID.
    try:
        step_addin = _get_translator(app, "step")
    except RuntimeError:
        raw_addin = app.ApplicationAddIns.ItemById(
            "{90AF7F40-0C01-11D5-8E83-0010B541CD80}"
        )
        step_addin = _cast_translator(raw_addin)
    _export_via_translator(app, doc, step_addin, file_path)
    return f"STEP-Export gespeichert: {file_path}"


@mcp.tool()
def get_properties() -> dict:
    """
    Liest zentrale iProperties (Design Tracking) des aktiven Dokuments aus.
    """
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None:
        raise RuntimeError("Kein aktives Dokument geoeffnet.")

    # "Design Tracking Properties"
    prop_set = doc.PropertySets.Item("Design Tracking Properties")
    wanted = ("Part Number", "Description", "Material", "Mass")
    result = {}
    for name in wanted:
        try:
            result[name] = prop_set.Item(name).Value
        except Exception:
            result[name] = None
    result["DisplayName"] = doc.DisplayName
    return result


# ===========================================================================
# MODELLIERUNG
# ===========================================================================

def _parse_direction(direction: str):
    """Wandelt Richtungs-String in Inventor-ExtentDirection-Konstante um."""
    d = direction.lower().strip()
    if d in ("positive", "pos", "up"):
        return _const.kPositiveExtentDirection
    elif d in ("negative", "neg", "down"):
        return _const.kNegativeExtentDirection
    elif d in ("symmetric", "sym", "both"):
        return _const.kSymmetricExtentDirection
    raise ValueError(
        f"Unbekannte Richtung '{direction}'. Erlaubt: 'positive', 'negative', 'symmetric'."
    )


def _rename_cylinder_params(comp_def, diameter_mm, height_mm):
    """Benennt die Parameter des Zylinders in lesbare Namen um."""
    diameter_cm = _mm_to_cm(diameter_mm)
    height_cm = _mm_to_cm(height_mm)
    for p in comp_def.Parameters:
        try:
            val = p.Value
            name_lower = p.Name.lower()
            if abs(val - diameter_cm) < 0.01 and name_lower.startswith("d"):
                p.Name = "Durchmesser"
            elif abs(val - height_cm) < 0.01 and name_lower.startswith("d"):
                p.Name = "Hoehe"
        except Exception:
            continue


def _rename_box_params(comp_def, length_mm, width_mm, height_mm):
    """Benennt die Parameter der Box in lesbare Namen um."""
    length_cm = _mm_to_cm(length_mm)
    width_cm = _mm_to_cm(width_mm)
    height_cm = _mm_to_cm(height_mm)
    for p in comp_def.Parameters:
        try:
            val = p.Value
            name_lower = p.Name.lower()
            if abs(val - length_cm) < 0.01 and name_lower.startswith("d"):
                p.Name = "Laenge"
            elif abs(val - width_cm) < 0.01 and name_lower.startswith("d"):
                p.Name = "Breite"
            elif abs(val - height_cm) < 0.01 and name_lower.startswith("d"):
                p.Name = "Hoehe"
        except Exception:
            continue


def _rename_cut_params(comp_def, length_mm, width_mm, depth_mm):
    """Benennt die Parameter der Tasche in lesbare Namen um."""
    length_cm = _mm_to_cm(length_mm)
    width_cm = _mm_to_cm(width_mm)
    depth_cm = _mm_to_cm(depth_mm)
    for p in comp_def.Parameters:
        try:
            val = p.Value
            name_lower = p.Name.lower()
            if name_lower.startswith("d"):
                if abs(val - length_cm) < 0.01:
                    p.Name = "Tasche_Laenge"
                elif abs(val - width_cm) < 0.01:
                    p.Name = "Tasche_Breite"
                elif abs(val - depth_cm) < 0.01:
                    p.Name = "Tasche_Tiefe"
        except Exception:
            continue


@mcp.tool()
def create_cylinder(
    diameter_mm: float,
    height_mm: float,
    direction: str = "positive",
) -> str:
    """
    Erstellt einen Zylinder: Kreis-Skizze auf der XY-Ebene + Extrusion.

    Args:
        diameter_mm: Durchmesser (mm).
        height_mm:   Hoehe der Extrusion (mm).
        direction:   Extrusionsrichtung: "positive" (Z+, Standard),
                     "negative" (Z-), "symmetric" (zentriert).
    """
    if diameter_mm <= 0 or height_mm <= 0:
        raise ValueError("Durchmesser und Hoehe muessen groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    radius = _mm_to_cm(diameter_mm) / 2.0
    height = _mm_to_cm(height_mm)

    sketch = comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3))
    center = tg.CreatePoint2d(0, 0)
    circle = sketch.SketchCircles.AddByCenterRadius(center, radius)
    constrain_status = _safe_constrain(
        lambda: _constrain_circle(
            app, sketch, comp_def, circle, 0, 0, radius * 2.0
        )
    )
    profile = sketch.Profiles.AddForSolid()

    ext_def = comp_def.Features.ExtrudeFeatures.CreateExtrudeDefinition(
        profile, _const.kNewBodyOperation
    )
    dir_enum = _parse_direction(direction)
    ext_def.SetDistanceExtent(height, dir_enum)
    comp_def.Features.ExtrudeFeatures.Add(ext_def)

    _rename_cylinder_params(comp_def, diameter_mm, height_mm)

    return (
        f"Zylinder erstellt: Durchmesser {diameter_mm} mm, Hoehe {height_mm} "
        f"mm, Richtung '{direction}'. Skizze: {constrain_status} bestimmt."
    )


@mcp.tool()
def extrude_cut(
    length_mm: float,
    width_mm: float,
    depth_mm: float,
    x_mm: float = 0.0,
    y_mm: float = 0.0,
    plane: str = "XY",
    start_offset_mm: float = 0.0,
    direction: str = "auto",
) -> str:
    """
    Schneidet eine rechteckige Tasche aus dem bestehenden Koerper (Material
    abtragen). Skizze auf einer beliebigen Ebene mit optionalem Offset.

    Args:
        length_mm:      Laenge des Rechtecks in X (mm).
        width_mm:       Breite des Rechtecks in Y (mm).
        depth_mm:       Schnitttiefe (mm).
        x_mm:           X-Position der linken unteren Ecke (mm, Standard 0).
        y_mm:           Y-Position der linken unteren Ecke (mm, Standard 0).
        plane:          Skizzebene: "XY" (Standard), "XZ", "YZ",
                        oder "XZ:30" (Ebene mit Offset in mm).
        start_offset_mm: Start-Offset der Extrusion von der Skizzebene (mm).
                         Positive Werte = in Extrusionsrichtung, negative = zurueck.
        direction:      "auto" (Standard) = Richtung aus Koerper ableiten,
                        "positive", "negative", "symmetric".
    """
    if min(length_mm, width_mm, depth_mm) <= 0:
        raise ValueError("Laenge, Breite und Tiefe muessen groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError(
            "Kein Koerper zum Schneiden vorhanden. Erst z. B. 'create_box'."
        )

    x = _mm_to_cm(x_mm)
    y = _mm_to_cm(y_mm)
    length = _mm_to_cm(length_mm)
    width = _mm_to_cm(width_mm)
    depth = _mm_to_cm(depth_mm)
    start_offset = _mm_to_cm(start_offset_mm)

    # Skizzebene bestimmen.
    work_plane = _resolve_work_plane(comp_def, plane)

    sketch = comp_def.Sketches.Add(work_plane)
    p1 = tg.CreatePoint2d(x, y)
    p2 = tg.CreatePoint2d(x + length, y + width)
    rect_lines = sketch.SketchLines.AddAsTwoPointRectangle(p1, p2)
    constrain_status = _safe_constrain(
        lambda: _constrain_rectangle(
            app, sketch, comp_def, rect_lines, x, y, length, width
        )
    )
    profile = sketch.Profiles.AddForSolid()

    ext_def = comp_def.Features.ExtrudeFeatures.CreateExtrudeDefinition(
        profile, _const.kCutOperation
    )

    # Richtung bestimmen.
    if direction.lower() == "auto":
        cut_dir = _detect_cut_direction(comp_def)
    else:
        cut_dir = _parse_direction(direction)

    # Offset + Tiefe setzen.
    if start_offset != 0:
        ext_def.SetDistanceExtentStart(start_offset)
    ext_def.SetDistanceExtent(depth, cut_dir)

    comp_def.Features.ExtrudeFeatures.Add(ext_def)

    _rename_cut_params(comp_def, length_mm, width_mm, depth_mm)

    return (
        f"Tasche geschnitten: {length_mm} x {width_mm} mm, "
        f"Tiefe {depth_mm} mm, Ebene '{plane}', "
        f"Offset {start_offset_mm} mm, Position ({x_mm}, {y_mm}). "
        f"Skizze: {constrain_status} bestimmt."
    )


def _geometry_value(item: dict, *names: str, required: bool = True, default=None):
    for name in names:
        if name in item:
            return float(item[name])
    if required:
        raise ValueError(f"Geometrie-Feld fehlt: eines von {', '.join(names)}")
    return default


def _add_generic_sketch_geometry(app, sketch, geometry: list[dict]):
    """Fuegt einfache, geschlossene oder offene 2D-Geometrie hinzu."""
    tg = app.TransientGeometry
    created = []
    for number, item in enumerate(geometry, start=1):
        if not isinstance(item, dict):
            raise ValueError(f"Geometrie #{number} muss ein Objekt sein.")
        kind = str(item.get("type", "")).strip().lower()
        construction = bool(item.get("construction", False))

        if kind == "line":
            start = tg.CreatePoint2d(
                _mm_to_cm(_geometry_value(item, "x1_mm", "start_x_mm")),
                _mm_to_cm(_geometry_value(item, "y1_mm", "start_y_mm")),
            )
            end = tg.CreatePoint2d(
                _mm_to_cm(_geometry_value(item, "x2_mm", "end_x_mm")),
                _mm_to_cm(_geometry_value(item, "y2_mm", "end_y_mm")),
            )
            entity = sketch.SketchLines.AddByTwoPoints(start, end)
        elif kind == "circle":
            center = tg.CreatePoint2d(
                _mm_to_cm(_geometry_value(item, "x_mm", "center_x_mm")),
                _mm_to_cm(_geometry_value(item, "y_mm", "center_y_mm")),
            )
            radius_mm = _geometry_value(item, "radius_mm")
            if radius_mm <= 0:
                raise ValueError("Kreisradius muss groesser als 0 sein.")
            entity = sketch.SketchCircles.AddByCenterRadius(
                center, _mm_to_cm(radius_mm)
            )
        elif kind == "rectangle":
            x1 = _geometry_value(item, "x1_mm", "left_mm")
            y1 = _geometry_value(item, "y1_mm", "bottom_mm")
            x2 = _geometry_value(item, "x2_mm", "right_mm")
            y2 = _geometry_value(item, "y2_mm", "top_mm")
            if x1 == x2 or y1 == y2:
                raise ValueError("Rechteck muss eine positive Flaeche haben.")
            entity = sketch.SketchLines.AddAsTwoPointRectangle(
                tg.CreatePoint2d(_mm_to_cm(x1), _mm_to_cm(y1)),
                tg.CreatePoint2d(_mm_to_cm(x2), _mm_to_cm(y2)),
            )
        elif kind in ("polyline", "polygon"):
            points = item.get("points")
            if not isinstance(points, list) or len(points) < 2:
                raise ValueError("Eine Polylinie braucht mindestens zwei Punkte.")
            point_objects = []
            for point in points:
                if isinstance(point, dict):
                    px = _geometry_value(point, "x_mm", "x")
                    py = _geometry_value(point, "y_mm", "y")
                elif isinstance(point, (list, tuple)) and len(point) == 2:
                    px, py = float(point[0]), float(point[1])
                else:
                    raise ValueError("Polylinienpunkte muessen [x, y] oder Objekte sein.")
                point_objects.append(tg.CreatePoint2d(_mm_to_cm(px), _mm_to_cm(py)))
            first = point_objects[0]
            previous = first
            entity = None
            for target in point_objects[1:]:
                entity = sketch.SketchLines.AddByTwoPoints(previous, target)
                previous = target
            if kind == "polygon":
                entity = sketch.SketchLines.AddByTwoPoints(previous, first)
        else:
            raise ValueError(
                f"Unbekannter Geometrietyp '{kind}'. Erlaubt: line, circle, "
                "rectangle, polyline, polygon."
            )

        if construction:
            try:
                entity.Construction = True
            except Exception:
                # Rechtecke/Polylinien liefern Collections bzw. die letzte
                # Linie; Konstruktion ist deshalb best-effort.
                pass
        created.append(kind)
    return created


def _find_sketch(comp_def, sketch_name: str):
    try:
        return comp_def.Sketches.Item(sketch_name)
    except Exception:
        for i in range(1, comp_def.Sketches.Count + 1):
            sketch = comp_def.Sketches.Item(i)
            if sketch.Name == sketch_name:
                return sketch
    raise RuntimeError(f"Skizze '{sketch_name}' nicht gefunden.")


@mcp.tool()
def create_sketch(
    geometry: list[dict],
    plane: str = "XY",
    name: str = "",
) -> dict:
    """Erstellt eine frei definierbare 2D-Skizze.

    ``geometry`` ist eine Liste aus ``line``, ``circle``, ``rectangle``,
    ``polyline`` oder ``polygon``. Koordinaten und Radien werden in mm
    angegeben. Beispiel: ``[{"type":"rectangle","x1_mm":0,
    "y1_mm":0,"x2_mm":40,"y2_mm":20}]``.
    """
    if not geometry:
        raise ValueError("Mindestens ein Geometrieelement ist erforderlich.")
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    sketch = doc.ComponentDefinition.Sketches.Add(
        _resolve_work_plane(doc.ComponentDefinition, plane)
    )
    if name.strip():
        sketch.Name = name.strip()
    created = _add_generic_sketch_geometry(app, sketch, geometry)
    return {
        "name": sketch.Name,
        "plane": plane,
        "geometry_count": len(created),
        "geometry_types": created,
        "profile_ready": True,
    }


@mcp.tool()
def extrude_sketch(
    sketch_name: str,
    distance_mm: float,
    operation: str = "new",
    direction: str = "positive",
) -> str:
    """Extrudiert eine vorhandene generische Skizze.

    ``operation`` ist ``new``, ``join`` oder ``cut``. Die Skizze muss ein
    geschlossenes Solid-Profil enthalten; Konstruktionsgeometrie wird von
    Inventor beim Profilaufbau ignoriert.
    """
    if distance_mm <= 0:
        raise ValueError("Die Extrusionsdistanz muss groesser als 0 sein.")
    op_map = {
        "new": _const.kNewBodyOperation,
        "join": _const.kJoinOperation,
        "cut": _const.kCutOperation,
    }
    operation_key = operation.strip().lower()
    if operation_key not in op_map:
        raise ValueError("operation muss 'new', 'join' oder 'cut' sein.")
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    sketch = _find_sketch(comp_def, sketch_name)
    try:
        profile = sketch.Profiles.AddForSolid()
    except Exception as exc:
        raise RuntimeError(
            f"Skizze '{sketch_name}' konnte nicht als Solid-Profil verwendet werden. "
            "Ist sie geschlossen?"
        ) from exc
    ext_def = comp_def.Features.ExtrudeFeatures.CreateExtrudeDefinition(
        profile, op_map[operation_key]
    )
    ext_def.SetDistanceExtent(_mm_to_cm(distance_mm), _parse_direction(direction))
    feature = comp_def.Features.ExtrudeFeatures.Add(ext_def)
    try:
        feature_name = feature.Name
    except Exception:
        feature_name = "Extrusion"
    return (
        f"Skizze '{sketch_name}' extrudiert: {distance_mm} mm, "
        f"Operation '{operation_key}', Richtung '{direction}', Feature '{feature_name}'."
    )


@mcp.tool()
def add_hole(
    x_mm: float,
    y_mm: float,
    diameter_mm: float,
    depth_mm: float = 0.0,
) -> str:
    """
    Fuegt eine Bohrung an Position (x, y) auf der XY-Ebene hinzu.

    Args:
        x_mm:        X-Position des Bohrungszentrums (mm).
        y_mm:        Y-Position des Bohrungszentrums (mm).
        diameter_mm: Bohrungsdurchmesser (mm).
        depth_mm:    Bohrtiefe (mm). 0 = Durchgangsbohrung (durch alles).
    """
    if diameter_mm <= 0:
        raise ValueError("Durchmesser muss groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    # Skizze mit einem Mittelpunkt fuer die Bohrung.
    sketch = comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3))
    hole_centers = app.TransientObjects.CreateObjectCollection()
    cx, cy = _mm_to_cm(x_mm), _mm_to_cm(y_mm)
    pt = sketch.SketchPoints.Add(tg.CreatePoint2d(cx, cy))
    hole_centers.Add(pt)

    # Lage des Bohrungsmittelpunkts bestimmen (Bemassung/Koinzidenz).
    def _constrain_point():
        geo = sketch.GeometricConstraints
        dim = sketch.DimensionConstraints
        origin_sp = _try_step(
            "Ursprung projizieren", lambda: _project_origin(sketch, comp_def)
        )
        status = "voll"
        if abs(cx) < 1e-6 and abs(cy) < 1e-6:
            def _do_coincident_hole():
                if _points_already_merged(pt, origin_sp):
                    return
                geo.AddCoincident(pt, origin_sp)

            _try_step("Koinzidenz Mittelpunkt-Ursprung", _do_coincident_hole)
        else:
            if abs(cx) > 1e-6:
                _try_step(
                    "Bemassung X-Position",
                    lambda: dim.AddTwoPointDistance(
                        origin_sp, pt, _const.kHorizontalDim,
                        tg.CreatePoint2d(cx / 2.0, cy - 0.5),
                    ),
                )
            else:
                status = "teilweise"
            if abs(cy) > 1e-6:
                _try_step(
                    "Bemassung Y-Position",
                    lambda: dim.AddTwoPointDistance(
                        origin_sp, pt, _const.kVerticalDim,
                        tg.CreatePoint2d(cx - 0.5, cy / 2.0),
                    ),
                )
            else:
                status = "teilweise"
        return status

    constrain_status = _safe_constrain(_constrain_point)

    diameter = _mm_to_cm(diameter_mm)
    hole_features = comp_def.Features.HoleFeatures
    hole_dir = _detect_cut_direction(comp_def)

    if depth_mm <= 0:
        # Durchgangsbohrung.
        hole_features.AddDrilledByThroughAllExtent(
            hole_centers, diameter, hole_dir
        )
        art = "Durchgangsbohrung"
    else:
        hole_features.AddDrilledByDistanceExtent(
            hole_centers,
            diameter,
            _mm_to_cm(depth_mm),
            hole_dir,
        )
        art = f"Bohrung (Tiefe {depth_mm} mm)"

    return (
        f"{art} erstellt: Durchmesser {diameter_mm} mm bei ({x_mm}, {y_mm}). "
        f"Skizze: {constrain_status} bestimmt."
    )


@mcp.tool()
def add_counterbore(
    x_mm: float,
    y_mm: float,
    diameter_mm: float,
    cbore_diameter_mm: float,
    cbore_depth_mm: float,
    depth_mm: float = 0.0,
) -> str:
    """
    Fuegt eine Gegenbohrung (Counterbore) an Position (x, y) auf der
    XY-Ebene hinzu.

    Args:
        x_mm:             X-Position des Bohrungszentrums (mm).
        y_mm:             Y-Position des Bohrungszentrums (mm).
        diameter_mm:      Durchmesser der Bohrung (mm).
        cbore_diameter_mm: Durchmesser der Gegenbohrung (mm).
        cbore_depth_mm:   Tiefe der Gegenbohrung (mm).
        depth_mm:         Gesamt-Tiefe (mm). 0 = Durchgang.
    """
    if min(diameter_mm, cbore_diameter_mm, cbore_depth_mm) <= 0:
        raise ValueError("Durchmesser und Tiefen muessen groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    sketch = comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3))
    hole_centers = app.TransientObjects.CreateObjectCollection()
    cx, cy = _mm_to_cm(x_mm), _mm_to_cm(y_mm)
    pt = sketch.SketchPoints.Add(tg.CreatePoint2d(cx, cy))
    hole_centers.Add(pt)

    constrain_status = _safe_constrain(
        lambda: _constrain_hole_point(sketch, comp_def, pt, cx, cy, tg)
    )

    diameter = _mm_to_cm(diameter_mm)
    cbore_dia = _mm_to_cm(cbore_diameter_mm)
    cbore_depth = _mm_to_cm(cbore_depth_mm)
    hole_dir = _detect_cut_direction(comp_def)

    if depth_mm <= 0:
        comp_def.Features.HoleFeatures.AddCBoreByThroughAllExtent(
            hole_centers, diameter, cbore_dia, cbore_depth
        )
        art = "Gegenbohrung (Durchgang)"
    else:
        comp_def.Features.HoleFeatures.AddCBoreByDistanceExtent2(
            hole_centers, diameter, _mm_to_cm(depth_mm),
            hole_dir, cbore_dia, cbore_depth,
        )
        art = f"Gegenbohrung (Tiefe {depth_mm} mm)"

    return (
        f"{art}: D {diameter_mm} mm, Gegenbohrung D {cbore_diameter_mm} x "
        f"{cbore_depth_mm} mm bei ({x_mm}, {y_mm}). "
        f"Skizze: {constrain_status} bestimmt."
    )


@mcp.tool()
def add_countersink(
    x_mm: float,
    y_mm: float,
    diameter_mm: float,
    csink_diameter_mm: float,
    csink_angle_deg: float = 90.0,
    depth_mm: float = 0.0,
) -> str:
    """
    Fuegt eine Senkkopfbohrung (Countersink) an Position (x, y) auf der
    XY-Ebene hinzu.

    Args:
        x_mm:              X-Position des Bohrungszentrums (mm).
        y_mm:              Y-Position des Bohrungszentrums (mm).
        diameter_mm:       Durchmesser der Bohrung (mm).
        csink_diameter_mm: Durchmesser der Senkung (mm).
        csink_angle_deg:   Senkwinkel in Grad (Standard 90).
        depth_mm:          Gesamt-Tiefe (mm). 0 = Durchgang.
    """
    if min(diameter_mm, csink_diameter_mm) <= 0:
        raise ValueError("Durchmesser muessen groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    sketch = comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3))
    hole_centers = app.TransientObjects.CreateObjectCollection()
    cx, cy = _mm_to_cm(x_mm), _mm_to_cm(y_mm)
    pt = sketch.SketchPoints.Add(tg.CreatePoint2d(cx, cy))
    hole_centers.Add(pt)

    constrain_status = _safe_constrain(
        lambda: _constrain_hole_point(sketch, comp_def, pt, cx, cy, tg)
    )

    diameter = _mm_to_cm(diameter_mm)
    csink_dia = _mm_to_cm(csink_diameter_mm)
    csink_angle_rad = math.radians(csink_angle_deg)
    hole_dir = _detect_cut_direction(comp_def)

    if depth_mm <= 0:
        comp_def.Features.HoleFeatures.AddCSinkByThroughAllExtent(
            hole_centers, diameter, csink_dia, csink_angle_rad,
        )
        art = "Senkkopfbohrung (Durchgang)"
    else:
        comp_def.Features.HoleFeatures.AddCSinkByDistanceExtent2(
            hole_centers, diameter, _mm_to_cm(depth_mm),
            hole_dir, csink_dia, csink_angle_rad,
        )
        art = f"Senkkopfbohrung (Tiefe {depth_mm} mm)"

    return (
        f"{art}: D {diameter_mm} mm, Senkung D {csink_diameter_mm} mm "
        f"({csink_angle_deg} Grad) bei ({x_mm}, {y_mm}). "
        f"Skizze: {constrain_status} bestimmt."
    )


def _constrain_hole_point(sketch, comp_def, pt, cx_cm, cy_cm, tg):
    """Hilfsfunktion: Bemassung eines Bohrungsmittelpunkts."""
    geo = sketch.GeometricConstraints
    dim = sketch.DimensionConstraints
    origin_sp = _project_origin(sketch, comp_def)
    status = "voll"
    if abs(cx_cm) < 1e-6 and abs(cy_cm) < 1e-6:
        if not _points_already_merged(pt, origin_sp):
            geo.AddCoincident(pt, origin_sp)
    else:
        if abs(cx_cm) > 1e-6:
            dim.AddTwoPointDistance(
                origin_sp, pt, _const.kHorizontalDim,
                tg.CreatePoint2d(cx_cm / 2.0, cy_cm - 0.5),
            )
        else:
            status = "teilweise"
        if abs(cy_cm) > 1e-6:
            dim.AddTwoPointDistance(
                origin_sp, pt, _const.kVerticalDim,
                tg.CreatePoint2d(cx_cm - 0.5, cy_cm / 2.0),
            )
        else:
            status = "teilweise"
    return status


@mcp.tool()
def add_fillet(radius_mm: float, edges: str = "all") -> str:
    """Verrundet Kanten des ersten Volumenkoerpers mit einem Radius.

    ``edges`` akzeptiert ``all``, ``top``, ``bottom`` und ``vertical`` sowie
    stabile Referenzen im Format ``face_id/edge_id``. Die alte Schreibweise
    ``F1:E1`` bleibt aus Kompatibilitaetsgruenden verfuegbar.
    """
    if radius_mm <= 0:
        raise ValueError("Radius muss groesser als 0 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    edge_coll, _ = _build_edge_collection(app, comp_def, edges)
    comp_def.Features.FilletFeatures.AddSimple(edge_coll, _mm_to_cm(radius_mm))
    return (
        f"Verrundung ({edges}) angewendet: Radius {radius_mm} mm "
        f"auf {edge_coll.Count} Kante(n)."
    )


@mcp.tool()
def add_chamfer(
    distance_mm: float,
    edges: str = "all",
    method: str = "distance",
    second_distance_mm: float = 0.0,
    angle_deg: float = 45.0,
    reference_face: str = "",
    automatic_edge_chain: bool = True,
    corner_setback: bool = True,
    preserve_all_features: bool = False,
) -> str:
    """Create an equal-distance, two-distance, or distance-angle chamfer.

    ``edges`` accepts ``all``, ``top``, ``bottom``, ``vertical``, stable
    ``face_id/edge_id`` references, and legacy ``F1:E1`` references.
    ``method`` is ``distance``, ``two_distances``, or ``distance_angle``.
    Asymmetric methods use ``reference_face`` to define which adjacent face
    receives the first distance or from which the angle is measured.  When it
    is omitted, the first adjacent face of the first edge is used.
    """
    if not math.isfinite(distance_mm) or distance_mm <= 0:
        raise ValueError("distance_mm must be greater than zero.")

    normalized_method = str(method).strip().lower().replace("-", "_")
    aliases = {
        "equal": "distance",
        "equal_distance": "distance",
        "two_distance": "two_distances",
        "angle": "distance_angle",
    }
    normalized_method = aliases.get(normalized_method, normalized_method)
    allowed_methods = ("distance", "two_distances", "distance_angle")
    if normalized_method not in allowed_methods:
        raise ValueError(
            f"Unknown chamfer method '{method}'. Allowed values: "
            + ", ".join(allowed_methods)
            + "."
        )
    if normalized_method == "two_distances" and (
        not math.isfinite(second_distance_mm) or second_distance_mm <= 0
    ):
        raise ValueError("second_distance_mm must be greater than zero.")
    if normalized_method == "distance_angle" and (
        not math.isfinite(angle_deg) or not 0 < angle_deg < 90
    ):
        raise ValueError("angle_deg must be greater than 0 and less than 90.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    edge_coll, selection = _build_edge_collection(app, comp_def, edges)
    chamfers = comp_def.Features.ChamferFeatures
    reference_kind = "not-used"
    if normalized_method == "distance":
        chamfer = chamfers.AddUsingDistance(
            edge_coll,
            _mm_to_cm(distance_mm),
            automatic_edge_chain,
            corner_setback,
            preserve_all_features,
        )
        detail = f"distance {distance_mm} mm"
    else:
        body = comp_def.SurfaceBodies.Item(1)
        face, reference_kind = _resolve_chamfer_face(
            body, edge_coll, reference_face
        )
        if normalized_method == "two_distances":
            chamfer = chamfers.AddUsingTwoDistances(
                edge_coll,
                face,
                _mm_to_cm(distance_mm),
                _mm_to_cm(second_distance_mm),
                automatic_edge_chain,
                preserve_all_features,
            )
            detail = f"distances {distance_mm} mm / {second_distance_mm} mm"
        else:
            chamfer = chamfers.AddUsingDistanceAndAngle(
                edge_coll,
                face,
                _mm_to_cm(distance_mm),
                math.radians(angle_deg),
                automatic_edge_chain,
                preserve_all_features,
            )
            detail = f"distance {distance_mm} mm at {angle_deg} degrees"
    return (
        f"Chamfer '{chamfer.Name}' created using {normalized_method}: {detail} "
        f"on {edge_coll.Count} edge(s) from '{selection}' "
        f"(reference face: {reference_kind})."
    )


# ===========================================================================
# SHELL, DRAFT, MIRROR
# ===========================================================================
@mcp.tool()
def shell(
    wall_thickness_mm: float,
    remove_faces: str = "",
    direction: str = "inside",
) -> str:
    """Create a uniform shell (German: Wandung) on the first solid body.

    ``remove_faces`` is a comma-separated list of stable ``geometry_id``
    values from ``list_faces``. Numeric legacy face indices remain supported.
    Leave it empty for a completely enclosed hollow body. ``direction`` can
    be ``inside``, ``outside``, or ``both``.
    """
    if not math.isfinite(wall_thickness_mm) or wall_thickness_mm <= 0:
        raise ValueError("wall_thickness_mm must be greater than zero.")

    normalized_direction = str(direction).strip().lower().replace("-", "_")
    direction_aliases = {
        "in": "inside",
        "out": "outside",
        "both_sides": "both",
        "symmetric": "both",
    }
    normalized_direction = direction_aliases.get(
        normalized_direction, normalized_direction
    )
    if normalized_direction not in ("inside", "outside", "both"):
        raise ValueError("direction must be inside, outside, or both.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    direction_map = {
        "inside": _const.kInsideShellDirection,
        "outside": _const.kOutsideShellDirection,
        "both": _const.kBothSidesShellDirection,
    }
    # Inventor expects None for an enclosed shell and a FaceCollection for
    # an open shell. Stable IDs avoid relying on topology collection order.
    face_coll = None
    if remove_faces.strip():
        face_coll = _build_face_collection(app, comp_def, remove_faces)

    shell_def = comp_def.Features.ShellFeatures.CreateShellDefinition(
        face_coll,
        _mm_to_cm(wall_thickness_mm),
        direction_map[normalized_direction],
    )
    shell_feature = comp_def.Features.ShellFeatures.Add(shell_def)

    return (
        f"Shell '{shell_feature.Name}' created with {wall_thickness_mm} mm "
        f"thickness directed {normalized_direction}; "
        + (
            f"{face_coll.Count} face(s) removed."
            if face_coll is not None
            else "no faces removed (enclosed hollow body)."
        )
    )


@mcp.tool()
def draft(
    face_indices: str,
    angle_deg: float,
    pull_direction: str = "Z",
    fixed_edge_index: int = 0,
) -> str:
    """
    Setzt Verjuengung (Draft) auf Flaechen fuer Formteile/Guss.

    Args:
        face_indices:    Kommagetrennte Indizes der zu verjuengenden Flaechen.
                         Beispiel: "2,4,6"
        angle_deg:       Verjuengungswinkel in Grad.
        pull_direction:  Zugrichtung: "X", "Y" oder "Z" (Standard "Z").
                         Oder ein Arbeitsflaechen-Name wie "Work Plane1".
        fixed_edge_index: Index der festen Kante (0 = keine, wird ignoriert).
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    body = comp_def.SurfaceBodies.Item(1)

    # Zu verjuengende Flaechen sammeln.
    face_coll = app.TransientObjects.CreateFaceCollection()
    for idx_str in face_indices.split(","):
        idx = int(idx_str.strip())
        if idx < 1 or idx > body.Faces.Count:
            raise ValueError(f"Flaechen-Index {idx} ungueltig.")
        face_coll.Add(body.Faces.Item(idx))

    # Zugrichtung bestimmen.
    pd = pull_direction.strip().upper()
    if pd in ("X", "Y", "Z"):
        axis_map = {"X": 1, "Y": 2, "Z": 3}
        pull_obj = comp_def.WorkAxes.Item(axis_map[pd])
    else:
        try:
            pull_obj = comp_def.WorkPlanes.Item(pull_direction.strip())
        except Exception:
            raise ValueError(f"Zugrichtung '{pull_direction}' nicht erkannt.")

    # Draft-Definition erstellen.
    draft_def = comp_def.Features.FaceDraftFeatures.CreateFaceDraftDefinition()
    draft_def.SetFixedPlane(face_coll, pull_obj, math.radians(angle_deg))

    comp_def.Features.FaceDraftFeatures.Add(draft_def)

    return (
        f"Draft erstellt: {len(face_indices.split(','))} Flaeche(n), "
        f"Winkel {angle_deg} Grad, Zugrichtung '{pull_direction}'."
    )


@mcp.tool()
def mirror_feature(feature_name: str, plane: str = "XY") -> str:
    """
    Spiegelt ein Feature ueber eine Arbeitsflaeche.

    Args:
        feature_name: Name des Features (z. B. "Extrusion1").
        plane:        Spiegelebene: "XY", "YZ", "XZ" oder Name wie "Work Plane1".
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )

    # Spiegelebene bestimmen.
    pl = plane.strip().upper()
    if pl in ("XY", "YZ", "XZ"):
        plane_map = {"XY": 3, "YZ": 1, "XZ": 2}
        mirror_plane = comp_def.WorkPlanes.Item(plane_map[pl])
    else:
        try:
            mirror_plane = comp_def.WorkPlanes.Item(plane.strip())
        except Exception:
            raise ValueError(f"Spiegelebene '{plane}' nicht gefunden.")

    # Feature-Collection fuer Spiegelung.
    feat_coll = app.TransientObjects.CreateObjectCollection()
    feat_coll.Add(feat)

    mirror_def = comp_def.Features.MirrorFeatures.CreateDefinition(
        feat_coll, mirror_plane
    )
    comp_def.Features.MirrorFeatures.AddByDefinition(mirror_def)

    return (
        f"Feature '{feature_name}' ({typ}) ueber '{plane}' gespiegelt."
    )


@mcp.tool()
def mirror_body(plane: str = "XY") -> str:
    """
    Spiegelt den gesamten Volumenkoerper ueber eine Arbeitsflaeche.
    Erzeugt einen neuen Koerper (kNewBodyOperation).

    Args:
        plane: Spiegelebene: "XY", "YZ", "XZ" oder Name wie "Work Plane1".
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    # Spiegelebene bestimmen.
    pl = plane.strip().upper()
    if pl in ("XY", "YZ", "XZ"):
        plane_map = {"XY": 3, "YZ": 1, "XZ": 2}
        mirror_plane = comp_def.WorkPlanes.Item(plane_map[pl])
    else:
        try:
            mirror_plane = comp_def.WorkPlanes.Item(plane.strip())
        except Exception:
            raise ValueError(f"Spiegelebene '{plane}' nicht gefunden.")

    # Koerper in Collection fuer Spiegelung.
    body_coll = app.TransientObjects.CreateObjectCollection()
    body_coll.Add(comp_def.SurfaceBodies.Item(1))

    mirror_def = comp_def.Features.MirrorFeatures.CreateDefinition(
        body_coll, mirror_plane
    )
    comp_def.Features.MirrorFeatures.AddByDefinition(mirror_def)

    return f"Koerper ueber '{plane}' gespiegelt. Neuer Koerper erstellt."


# ===========================================================================
# PARAMETRIK
# ===========================================================================
@mcp.tool()
def get_parameters() -> list:
    """
    Listet alle Modell-Parameter des aktiven Bauteils mit Name, Ausdruck
    und Wert (in cm/rad, Inventor-intern) auf.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    params = []
    for p in comp_def.Parameters:
        try:
            params.append(
                {
                    "name": p.Name,
                    "expression": p.Expression,
                    "value": p.Value,
                    "unit": p.Units,
                }
            )
        except Exception:
            continue
    return params


@mcp.tool()
def set_parameter(name: str, expression: str) -> str:
    """
    Setzt einen benannten Parameter ueber einen Ausdruck und aktualisiert
    das Modell. Beispiel: set_parameter("d1", "50 mm").

    Args:
        name:       Parametername (siehe 'get_parameters').
        expression: Neuer Ausdruck inkl. Einheit, z. B. "50 mm" oder "30 deg".
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    try:
        param = comp_def.Parameters.Item(name)
    except Exception:
        raise RuntimeError(
            f"Parameter '{name}' nicht gefunden. Verfuegbare Namen via "
            "'get_parameters' abrufen."
        )

    param.Expression = expression
    doc.Update()
    return f"Parameter '{name}' auf '{expression}' gesetzt und Modell aktualisiert."


# ===========================================================================
# DATEI & EXPORT
# ===========================================================================
@mcp.tool()
def save_document(file_path: str = "") -> str:
    """
    Speichert das aktive Dokument. Ohne Pfad wird 'Save' verwendet (nur wenn
    das Dokument bereits einen Speicherort hat), sonst 'SaveAs'.

    Args:
        file_path: Optionaler Zielpfad, z. B. C:/temp/teil.ipt
    """
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None:
        raise RuntimeError("Kein aktives Dokument geoeffnet.")

    if file_path:
        # Zweiter Parameter False = normal speichern (nicht nur als Kopie).
        doc.SaveAs(file_path, False)
        return f"Dokument gespeichert unter: {file_path}"

    doc.Save()
    return "Dokument gespeichert."


@mcp.tool()
def open_document(file_path: str) -> str:
    """
    Oeffnet ein bestehendes Dokument (.ipt / .iam / .idw) und macht es aktiv.

    Args:
        file_path: Vollstaendiger Pfad zur Datei.
    """
    app = _get_app()
    doc = app.Documents.Open(file_path, True)
    try:
        display = doc.DisplayName
    except Exception:
        display = file_path
    return f"Dokument geoeffnet: {display}"


@mcp.tool()
def export_stl(file_path: str) -> str:
    """
    Exportiert das aktive Bauteil als STL-Datei (fuer 3D-Druck).

    Args:
        file_path: Vollstaendiger Zielpfad, z. B. C:/temp/teil.stl
    """
    app = _get_app()
    doc = _require_part_document(app)
    addin = _get_translator(app, "stl")
    _export_via_translator(app, doc, addin, file_path)
    return f"STL-Export gespeichert: {file_path}"


@mcp.tool()
def export_dxf(file_path: str) -> str:
    """
    Exportiert als DXF. Hinweis: DXF eignet sich vor allem fuer 2D bzw.
    Blech-Abwicklungen (Flat Pattern). Bei reinen 3D-Volumenteilen ohne
    Abwicklung ist das Ergebnis ggf. leer.

    Args:
        file_path: Vollstaendiger Zielpfad, z. B. C:/temp/teil.dxf
    """
    app = _get_app()
    doc = _require_part_document(app)
    addin = _get_translator(app, "dxf")
    _export_via_translator(app, doc, addin, file_path)
    return f"DXF-Export gespeichert: {file_path}"


# ===========================================================================
# AUSLESEN
# ===========================================================================
@mcp.tool()
def get_mass_properties() -> dict:
    """
    Liefert Masse (kg), Volumen (cm^3), Oberflaeche (cm^2) und Schwerpunkt
    (mm) des aktiven Bauteils.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition
    mp = comp_def.MassProperties

    com = mp.CenterOfMass  # Point in cm
    return {
        "mass_kg": mp.Mass,          # Inventor liefert Masse in kg
        "volume_cm3": mp.Volume,     # cm^3
        "area_cm2": mp.Area,         # cm^2
        "center_of_mass_mm": {
            "x": com.X * 10.0,
            "y": com.Y * 10.0,
            "z": com.Z * 10.0,
        },
    }


@mcp.tool()
def list_bodies() -> list:
    """
    Listet alle Volumenkoerper des aktiven Bauteils mit ID,
    Bounding-Box, Volumen und Oberflaeche auf.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    result = []
    for i in range(1, comp_def.SurfaceBodies.Count + 1):
        body = comp_def.SurfaceBodies.Item(i)
        info = {"index": i, "name": body.Name}
        try:
            info["id"] = body.Id
        except Exception:
            pass
        try:
            box = body.RangeBox
            info["bounding_box_mm"] = {
                "length_x": round((box.MaxPoint.X - box.MinPoint.X) * 10.0, 4),
                "width_y": round((box.MaxPoint.Y - box.MinPoint.Y) * 10.0, 4),
                "height_z": round((box.MaxPoint.Z - box.MinPoint.Z) * 10.0, 4),
            }
        except Exception:
            pass
        try:
            info["volume_cm3"] = round(body.Volume, 6)
        except Exception:
            pass
        try:
            info["surface_area_cm2"] = round(body.Area, 6)
        except Exception:
            pass
        try:
            info["face_count"] = body.Faces.Count
        except Exception:
            pass
        try:
            info["edge_count"] = body.Edges.Count
        except Exception:
            pass
        result.append(info)
    return result


@mcp.tool()
def get_bounding_box() -> dict:
    """
    Liefert die exakten Abmessungen des ersten Volumenkoerpers
    (Bounding-Box) in mm.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    body = comp_def.SurfaceBodies.Item(1)
    try:
        box = body.RangeBox
    except Exception as exc:
        raise RuntimeError(f"RangeBox nicht verfuegbar: {exc}")

    x_min, y_min, z_min = box.MinPoint.X, box.MinPoint.Y, box.MinPoint.Z
    x_max, y_max, z_max = box.MaxPoint.X, box.MaxPoint.Y, box.MaxPoint.Z

    return {
        "length_x_mm": round((x_max - x_min) * 10.0, 4),
        "width_y_mm": round((y_max - y_min) * 10.0, 4),
        "height_z_mm": round((z_max - z_min) * 10.0, 4),
        "min": {
            "x_mm": round(x_min * 10.0, 4),
            "y_mm": round(y_min * 10.0, 4),
            "z_mm": round(z_min * 10.0, 4),
        },
        "max": {
            "x_mm": round(x_max * 10.0, 4),
            "y_mm": round(y_max * 10.0, 4),
            "z_mm": round(z_max * 10.0, 4),
        },
    }


@mcp.tool()
def list_faces() -> list:
    """
    Listet alle Flaechen des ersten Volumenkoerpers mit Index, Typ
    (planar/cylindrical/conical/etc.) und Flaeche (cm^2) auf.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    # SurfaceType Enums aus Inventors Typbibliothek.
    _surface_types = {
        5890: "cylinder",
        5891: "plane",
        5892: "cone",
        5893: "sphere",
        5894: "torus",
        5895: "surface",
        5896: "nurbs",
    }

    body = comp_def.SurfaceBodies.Item(1)
    result = []
    for i in range(1, body.Faces.Count + 1):
        face = body.Faces.Item(i)
        info = {"index": i, "geometry_id": _get_geometry_id(face, "face")}
        try:
            st = face.SurfaceType
            info["surface_type"] = _surface_types.get(st, f"unknown({st})")
        except Exception:
            info["surface_type"] = "unknown"
        try:
            info["area_cm2"] = round(face.Area, 6)
        except Exception:
            pass
        try:
            info["edge_count"] = face.Edges.Count
        except Exception:
            pass
        result.append(info)
    return result


@mcp.tool()
def list_features() -> list:
    """
    Listet die vorhandenen Features des aktiven Bauteils nach Typ auf
    (die Typen, die dieser Server erzeugen kann).
    """
    app = _get_app()
    doc = _require_part_document(app)
    feats = doc.ComponentDefinition.Features

    collections = {
        "Extrude": "ExtrudeFeatures",
        "Hole": "HoleFeatures",
        "Fillet": "FilletFeatures",
        "Chamfer": "ChamferFeatures",
        "Revolve": "RevolveFeatures",
        "Shell": "ShellFeatures",
        "Draft": "FaceDraftFeatures",
        "Mirror": "MirrorFeatures",
        "Sweep": "SweepFeatures",
        "Loft": "LoftFeatures",
        "Thread": "ThreadFeatures",
    }

    result = []
    for typ, attr in collections.items():
        try:
            coll = getattr(feats, attr)
            for i in range(1, coll.Count + 1):
                item = coll.Item(i)
                result.append({"type": typ, "name": item.Name})
        except Exception:
            continue
    return result


def _find_feature(comp_def, feature_name: str):
    """Sucht ein Feature nach Name in allen typisierten Sammlungen."""
    collections = {
        "Extrude": "ExtrudeFeatures",
        "Hole": "HoleFeatures",
        "Fillet": "FilletFeatures",
        "Chamfer": "ChamferFeatures",
        "Revolve": "RevolveFeatures",
        "Shell": "ShellFeatures",
        "Draft": "FaceDraftFeatures",
        "Mirror": "MirrorFeatures",
        "Sweep": "SweepFeatures",
        "Loft": "LoftFeatures",
        "Thread": "ThreadFeatures",
    }
    for typ, attr in collections.items():
        try:
            coll = getattr(comp_def.Features, attr)
            for i in range(1, coll.Count + 1):
                item = coll.Item(i)
                if item.Name == feature_name:
                    return item, typ
        except Exception:
            continue
    return None, None


# ===========================================================================
# FEATURE MANIPULATION (LOESCHEN, VERSCHIEBEN, SKIZZENE)
# ===========================================================================
@mcp.tool()
def delete_feature(feature_name: str) -> str:
    """
    Loescht ein Feature nach seinem Namen.

    Args:
        feature_name: Name des Features (z. B. "Extrusion1", "Hole1").
                      Namen ueber 'list_features' ermitteln.
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )

    feat.Delete(False, False, False)
    return f"Feature '{feature_name}' (Typ: {typ}) geloescht."


@mcp.tool()
def move_feature(feature_name: str, direction: str = "up") -> str:
    """
    Verschiebt ein Feature in der Chronologie (Browser-Reihenfolge).
    Verschiebt den End-of-Part-Marker relativ zum Feature.

    Args:
        feature_name: Name des Features (z. B. "Extrusion1").
        direction:    "up" = Feature nach oben (vor die nachfolgenden),
                      "down" = Feature nach unten (nach den vorherigen).
    """
    if direction not in ("up", "down"):
        raise ValueError("direction muss 'up' oder 'down' sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )

    try:
        feat.SetEndOfPart(direction == "up")
    except Exception as exc:
        raise RuntimeError(
            f"Verschieben von '{feature_name}' fehlgeschlagen: {exc}"
        )

    return (
        f"Feature '{feature_name}' (Typ: {typ}) "
        f"nach {direction} verschoben."
    )


@mcp.tool()
def change_sketch_plane(feature_name: str, plane: str) -> str:
    """
    Ändert die Skizzenebene eines skizzenbasierten Features
    (Extrude, Revolve) auf eine andere Arbeitsflaechen oder Flaechen.

    Args:
        feature_name: Name des Features (z. B. "Extrusion1").
        plane:        Zielebene. Erlaubt:
                      - "XY", "YZ", "XZ" fuer die drei Standard-Arbeitsflaechen
                      - "Work Plane1", "Work Plane2", ... fuer benannte Ebenen
                      - "Face1", "Face2", ... fuer Flaechen des Koerpers
                        (Nummer wie in der Inventor-Oberflaeche)
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )

    if typ not in ("Extrude", "Revolve"):
        raise RuntimeError(
            f"Feature '{feature_name}' ist Typ '{typ}'. "
            "Nur Extrude und Revolve haben eine Skizzene."
        )

    # Skizze am Feature holen.
    try:
        sketch = feat.Sketch
    except Exception:
        raise RuntimeError(
            f"Kein Zugriff auf die Skizze von '{feature_name}'."
        )

    # Neue Ebene bestimmen.
    new_entity = None
    plane_upper = plane.strip().upper()

    if plane_upper in ("XY", "YZ", "XZ"):
        plane_map = {"XY": 3, "YZ": 1, "XZ": 2}
        idx = plane_map[plane_upper]
        new_entity = comp_def.WorkPlanes.Item(idx)
    elif plane_upper.startswith("WORK PLANE"):
        try:
            new_entity = comp_def.WorkPlanes.Item(plane.strip())
        except Exception:
            try:
                idx = int(plane_upper.replace("WORK PLANE", "").strip())
                new_entity = comp_def.WorkPlanes.Item(idx)
            except Exception:
                raise RuntimeError(
                    f"Arbeitsflaeche '{plane}' nicht gefunden."
                )
    elif plane_upper.startswith("FACE"):
        try:
            face_idx = int(plane_upper.replace("FACE", "").strip())
            new_entity = comp_def.SurfaceBodies.Item(1).Faces.Item(face_idx)
        except Exception:
            raise RuntimeError(f"Flaeche '{plane}' nicht gefunden.")
    else:
        raise ValueError(
            f"Ungueltiger Ebenen-Angabe '{plane}'. "
            "Erlaubt: 'XY'/'YZ'/'XZ', 'Work Plane<N>', 'Face<N>'."
        )

    try:
        sketch.PlanarEntity = new_entity
    except Exception as exc:
        raise RuntimeError(
            f"Umschalten der Skizenebene fehlgeschlagen: {exc}"
        )

    doc.Update()
    return (
        f"Skizenebene von '{feature_name}' auf '{plane}' geaendert."
    )


# ===========================================================================
# KANTENAUSWAHL AN FLAECHEN
# ===========================================================================
@mcp.tool()
def list_face_edges(face_index: str = "1") -> list:
    """
    Listet die Kanten einer Flaechen des ersten Volumenkoerpers auf.
    Liefert Index, Typ (gerade/kruemm), Z-Start, Z-Stop pro Kante.

    Args:
        face_index: Stabile Flaechen-ID aus 'list_faces'. Eine numerische
                    Angabe bleibt als legacy Index erlaubt.
    """
    app = _get_app()
    doc = _require_part_document(app)
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    body = comp_def.SurfaceBodies.Item(1)
    face, reference_kind = _resolve_face_reference(body, str(face_index))
    result = []
    for i in range(1, face.Edges.Count + 1):
        edge = face.Edges.Item(i)
        info = {
            "index": i,
            "geometry_id": _get_geometry_id(edge, "edge"),
            "face_reference_kind": reference_kind,
        }
        try:
            geom_type = edge.GeometryType
            info["geometry_type"] = geom_type
        except Exception:
            pass
        try:
            z1 = edge.StartVertex.Point.Z
            z2 = edge.StopVertex.Point.Z
            info["z_start"] = round(z1, 6)
            info["z_stop"] = round(z2, 6)
            if abs(z1 - z2) < 1e-4:
                info["orientation"] = "horizontal"
            else:
                info["orientation"] = "vertical"
        except Exception:
            info["orientation"] = "curved"
        result.append(info)
    return result


def _get_fillet_feature(comp_def, feature_name: str):
    """Sucht ein Fillet-Feature und liefert (feat, typ)."""
    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )
    if typ != "Fillet":
        raise RuntimeError(
            f"Feature '{feature_name}' ist Typ '{typ}', nicht 'Fillet'."
        )
    return feat


def _get_chamfer_feature(comp_def, feature_name: str):
    """Sucht ein Chamfer-Feature und liefert (feat, typ)."""
    feat, typ = _find_feature(comp_def, feature_name)
    if feat is None:
        raise RuntimeError(
            f"Feature '{feature_name}' nicht gefunden. "
            "Namen mit 'list_features' pruefen."
        )
    if typ != "Chamfer":
        raise RuntimeError(
            f"Feature '{feature_name}' ist Typ '{typ}', nicht 'Chamfer'."
        )
    return feat


def _build_edge_collection(app, comp_def, edge_specs: str):
    """
    Baut eine EdgeCollection aus einer Spezifikation.
    edge_specs: Kommagetrennte Liste von Angaben wie:
        "face_id/edge_id" -> stabile Flaechen- und Kanten-ID
        "F1:E1,F1:E3"     -> legacy Indexe
        "top"              -> alle oberen Kanten (wie bei fillet/chamfer)
        "bottom"           -> alle unteren Kanten
        "vertical"         -> alle senkrechten Kanten
        "all"              -> alle Kanten
    """
    spec = edge_specs.strip().lower()

    if spec in ("all", "top", "bottom", "vertical"):
        return _filtered_edges(app, comp_def, spec), spec

    coll = app.TransientObjects.CreateEdgeCollection()
    body = comp_def.SurfaceBodies.Item(1)
    parts = [p.strip() for p in edge_specs.split(",") if p.strip()]

    for part in parts:
        if "/" in part:
            face_ref, edge_ref = [value.strip() for value in part.split("/", 1)]
            face, _ = _resolve_face_reference(body, face_ref)
            edge, _ = _resolve_edge_reference(body, edge_ref)
            # Verhindert, dass versehentlich eine Kante aus einer anderen
            # Flaeche ueber eine unpassende Kombination selektiert wird.
            edge_id = _get_geometry_id(edge, "edge")
            valid = any(
                _get_geometry_id(face.Edges.Item(i), "edge") == edge_id
                for i in range(1, face.Edges.Count + 1)
            )
            if not valid:
                raise ValueError(f"Kante '{edge_ref}' gehoert nicht zu Flaeche '{face_ref}'.")
            coll.Add(edge)
            continue

        if ":" not in part:
            raise ValueError(
                f"Ungueltiges Format '{part}'. Erwartet 'face_id/edge_id' "
                "oder legacy 'F<idx>:E<idx>'."
            )
        face_str, edge_str = part.split(":", 1)
        face_ref = face_str.strip()
        edge_ref = edge_str.strip()
        if face_ref.upper().startswith("F"):
            face_ref = face_ref[1:]
        if edge_ref.upper().startswith("E"):
            edge_ref = edge_ref[1:]
        face, _ = _resolve_face_reference(body, face_ref)
        if edge_ref.isdigit():
            edge_idx = int(edge_ref)
            if edge_idx < 1 or edge_idx > face.Edges.Count:
                raise ValueError(f"Kanten-Index {edge_idx} auf Flaeche ungueltig.")
            coll.Add(face.Edges.Item(edge_idx))
        else:
            edge, _ = _resolve_edge_reference(body, edge_ref)
            coll.Add(edge)

    if coll.Count == 0:
        raise RuntimeError("Keine Kanten aus der Angabe extrahiert.")
    return coll, edge_specs


@mcp.tool()
def change_fillet_edges(feature_name: str, edges: str) -> str:
    """
    Ändert die Kanten-Auswahl eines bestehenden Fillet-Features.
    Das Feature wird geloescht und mit den neuen Kanten neu erstellt.
    Radius und andere Einstellungen bleiben erhalten.

    Args:
        feature_name: Name des Fillet-Features (z. B. "Fillet1").
        edges:        Neue Kanten-Angabe. Erlaubt:
                      - "all", "top", "bottom", "vertical"
                      - "F1:E1,F1:E3" (Flaeche 1, Kanten 1 und 3)
                      - Kombination: "F1:E1,top"
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat = _get_fillet_feature(comp_def, feature_name)

    # Alten Radius auslesen.
    try:
        radius_cm = feat.Parameters.Item(1).Value
        radius_mm = radius_cm * 10.0
    except Exception:
        radius_mm = None

    # Alte Einstellungen auslesen.
    try:
        auto_chain = feat.AutomaticEdgeChain
    except Exception:
        auto_chain = True
    try:
        roll_sharp = feat.RollAlongSharpEdges
    except Exception:
        roll_sharp = False

    # Neue Kanten bauen.
    new_edges, _ = _build_edge_collection(app, comp_def, edges)

    # Altes Feature loeschen.
    feat.Delete(False, False, False)

    # Neues Feature mit gleichen Einstellungen erstellen.
    if radius_mm is not None:
        comp_def.Features.FilletFeatures.AddSimple(
            new_edges,
            _mm_to_cm(radius_mm),
            False,
            False,
            auto_chain,
            roll_sharp,
        )
    else:
        comp_def.Features.FilletFeatures.AddSimple(new_edges, 0.1)

    return (
        f"Fillet '{feature_name}' neu erstellt: "
        f"{new_edges.Count} Kante(n), "
        f"Radius {radius_mm if radius_mm else '?'} mm."
    )


@mcp.tool()
def change_chamfer_edges(feature_name: str, edges: str) -> str:
    """Change the selection of an equal-distance chamfer.

    Two-distance and distance-angle chamfers are intentionally rejected here
    because recreating them also requires an unambiguous reference face. Use
    ``add_chamfer`` with the desired method after deleting those features.

    Args:
        feature_name: Name des Chamfer-Features (z. B. "Chamfer1").
        edges:        Neue Kanten-Angabe (siehe 'change_fillet_edges').
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    feat = _get_chamfer_feature(comp_def, feature_name)

    try:
        definition = feat.Definition
        definition_type = definition.DefinitionType
    except Exception as exc:
        raise RuntimeError(
            f"Could not read the definition of chamfer '{feature_name}': {exc}"
        ) from exc
    if definition_type != _const.kDistance:
        raise RuntimeError(
            "change_chamfer_edges only supports equal-distance chamfers. "
            "Delete this asymmetric chamfer and recreate it with add_chamfer "
            "so reference_face remains explicit."
        )

    try:
        dist_cm = definition.Distance.Value
        dist_mm = dist_cm * 10.0
    except Exception:
        dist_mm = None

    try:
        auto_chain = definition.AutomaticEdgeChain
    except Exception:
        auto_chain = True
    try:
        corner_setback = definition.CornerSetback
    except Exception:
        corner_setback = True
    try:
        preserve_all_features = definition.PreserveAllFeatures
    except Exception:
        preserve_all_features = False

    # Neue Kanten bauen.
    new_edges, _ = _build_edge_collection(app, comp_def, edges)

    # Altes Feature loeschen.
    feat.Delete(False, False, False)

    # Neues Feature mit gleichen Einstellungen erstellen.
    if dist_mm is not None:
        comp_def.Features.ChamferFeatures.AddUsingDistance(
            new_edges,
            _mm_to_cm(dist_mm),
            auto_chain,
            corner_setback,
            preserve_all_features,
        )
    else:
        comp_def.Features.ChamferFeatures.AddUsingDistance(
            new_edges,
            0.1,
            auto_chain,
            corner_setback,
            preserve_all_features,
        )

    return (
        f"Chamfer '{feature_name}' neu erstellt: "
        f"{new_edges.Count} Kante(n), "
        f"Distanz {dist_mm if dist_mm else '?'} mm."
    )


# ===========================================================================
# ROTATIONSKOERPER (REVOLVE)
# ===========================================================================
@mcp.tool()
def create_revolve(
    outer_radius_mm: float,
    height_mm: float,
    inner_radius_mm: float = 0.0,
    angle_deg: float = 360.0,
) -> str:
    """
    Erstellt einen Rotationskoerper (Scheibe / Ring / Rohr) durch Rotation
    eines Rechteckprofils um die Y-Achse.

    Args:
        outer_radius_mm: Aussenradius (mm).
        height_mm:       Hoehe entlang der Y-Achse (mm).
        inner_radius_mm: Innenradius (mm). 0 = Vollkoerper, >0 = Rohr/Ring.
        angle_deg:       Rotationswinkel in Grad (360 = voller Koerper).
    """
    if outer_radius_mm <= 0 or height_mm <= 0:
        raise ValueError("Aussenradius und Hoehe muessen groesser als 0 sein.")
    if inner_radius_mm < 0 or inner_radius_mm >= outer_radius_mm:
        raise ValueError("Innenradius muss >=0 und < Aussenradius sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    r_out = _mm_to_cm(outer_radius_mm)
    r_in = _mm_to_cm(inner_radius_mm)
    height = _mm_to_cm(height_mm)

    # Rechteckprofil in der XY-Ebene, versetzt vom Ursprung entlang X.
    sketch = comp_def.Sketches.Add(comp_def.WorkPlanes.Item(3))
    p1 = tg.CreatePoint2d(r_in, 0)
    p2 = tg.CreatePoint2d(r_out, height)
    rect_lines = sketch.SketchLines.AddAsTwoPointRectangle(p1, p2)
    constrain_status = _safe_constrain(
        lambda: _constrain_rectangle(
            app, sketch, comp_def, rect_lines, r_in, 0, r_out - r_in, height
        )
    )
    profile = sketch.Profiles.AddForSolid()

    # Rotationsachse = Y-Achse (WorkAxes.Item(2)).
    axis = comp_def.WorkAxes.Item(2)
    rev_features = comp_def.Features.RevolveFeatures

    if angle_deg >= 360.0:
        rev_features.AddFull(profile, axis, _const.kNewBodyOperation)
        art = "Vollkoerper (360 grd)"
    else:
        angle_rad = math.radians(angle_deg)
        rev_features.AddByAngle(
            profile,
            axis,
            angle_rad,
            _const.kPositiveExtentDirection,
            _const.kNewBodyOperation,
        )
        art = f"Teilkoerper ({angle_deg} grd)"

    kind = "Rohr/Ring" if inner_radius_mm > 0 else "Scheibe/Zylinder"
    return (
        f"Rotationskoerper erstellt ({kind}, {art}). "
        f"Skizze: {constrain_status} bestimmt."
    )


@mcp.tool()
def create_revolved_profile(
    points: str,
    axis: str = "Y",
    angle_deg: float = 360.0,
    plane: str = "XY",
    operation: str = "new",
) -> str:
    """
    Erstellt einen Rotationskoerper aus einem frei definierbaren 2D-Profil.
    Das Profil wird als geschlossene Punktkette uebergeben und um eine
    Achse rotiert.

    Args:
        points:    2D-Punkte des Profils (in mm), semikolongetrennt.
                   Format: "x1,y1;x2,y2;x3,y3;..." (Koordinaten in der
                   Skizzebene, x = Abstand von Rotationsachse,
                   y = Hoehe entlang der Achse).
                   Das Profil muss geschlossen sein (erster und letzter
                   Punkte sollten übereinstimmen oder die Skizze wird
                   automatisch geschlossen).
        axis:      Rotationsachse: "X", "Y" oder "Z" (Standard "Y").
        angle_deg: Rotationswinkel in Grad (Standard 360 = voller Koerper).
        plane:     Skizzebene fuer das Profil: "XY", "XZ", "YZ" oder
                   Offset wie "XZ:30" (Standard "XY").
        operation: "new" = neuer Koerper, "join" = verbinden, "cut" = schneiden.
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    # Punkte parsen.
    raw_points = [p.strip() for p in points.split(";") if p.strip()]
    if len(raw_points) < 3:
        raise ValueError("Mindestens 3 Punkte noetig fuer ein Profil.")

    points_2d = []
    for pt_str in raw_points:
        parts = pt_str.split(",")
        if len(parts) != 2:
            raise ValueError(
                f"Ungueltiger Punkt: '{pt_str}'. Erwartet 'x,y' (in mm)."
            )
        x, y = float(parts[0]), float(parts[1])
        points_2d.append(tg.CreatePoint2d(_mm_to_cm(x), _mm_to_cm(y)))

    # Skizze anlegen.
    work_plane = _resolve_work_plane(comp_def, plane)
    sketch = comp_def.Sketches.Add(work_plane)

    # Profil zeichnen: Polylinie aus Linien (sequenziell, damit Endpunkte
    # automatisch verbunden werden).
    first_line = sketch.SketchLines.AddByTwoPoints(
        points_2d[0], points_2d[1]
    )
    prev_line = first_line
    for i in range(2, len(points_2d)):
        new_line = sketch.SketchLines.AddByTwoPoints(
            prev_line.EndSketchPoint, points_2d[i]
        )
        prev_line = new_line

    # Profil schliessen falls noetig.
    dx = abs(points_2d[0].X - points_2d[-1].X)
    dy = abs(points_2d[0].Y - points_2d[-1].Y)
    if dx > 1e-6 or dy > 1e-6:
        sketch.SketchLines.AddByTwoPoints(
            prev_line.EndSketchPoint, first_line.StartSketchPoint
        )

    profile = sketch.Profiles.AddForSolid()

    # Rotationsachse bestimmen.
    axis_map = {"X": 1, "Y": 2, "Z": 3}
    axis_upper = axis.strip().upper()
    if axis_upper not in axis_map:
        raise ValueError(f"Unbekannte Achse: '{axis}'. Erlaubt: X, Y, Z.")
    rot_axis = comp_def.WorkAxes.Item(axis_map[axis_upper])

    # Rotations-Operation.
    op_map = {
        "new": _const.kNewBodyOperation,
        "join": _const.kJoinOperation,
        "cut": _const.kCutOperation,
    }
    op = op_map.get(operation.lower(), _const.kNewBodyOperation)

    rev_features = comp_def.Features.RevolveFeatures
    if angle_deg >= 360.0:
        rev_features.AddFull(profile, rot_axis, op)
        art = "Vollkoerper (360 grd)"
    else:
        angle_rad = math.radians(angle_deg)
        rev_features.AddByAngle(
            profile, rot_axis, angle_rad,
            _const.kPositiveExtentDirection, op,
        )
        art = f"Teilkoerper ({angle_deg} grd)"

    return (
        f"Rotationskoerper aus freiem Profil erstellt ({art}). "
        f"{len(raw_points)} Punkte, Achse '{axis}', Ebene '{plane}', "
        f"Operation '{operation}'."
    )


# ===========================================================================
# SWEEP, LOFT, GEWINDE, NUT
# ===========================================================================
@mcp.tool()
def sweep(
    profile_diameter_mm: float,
    path_points: str,
    operation: str = "new",
    profile_shape: str = "circle",
    profile_width_mm: float = 0.0,
    profile_height_mm: float = 0.0,
    profile_orientation: str = "normal",
    twist_angle_deg: float = 0.0,
    taper_angle_deg: float = 0.0,
) -> str:
    """Sweep a circle or rectangle along a connected polyline in 3D space.

    ``path_points`` uses ``x,y,z;x,y,z`` coordinates in millimetres. The
    profile is created at the first point on a construction plane normal to
    the first segment. ``profile_shape`` is ``circle`` or ``rectangle``.
    Rectangle profiles require ``profile_width_mm`` and
    ``profile_height_mm``. Orientation is ``normal`` or ``parallel``.
    """
    normalized_shape = str(profile_shape).strip().lower()
    if normalized_shape not in ("circle", "rectangle", "rect"):
        raise ValueError("profile_shape must be circle or rectangle.")
    if normalized_shape == "circle" and (
        not math.isfinite(profile_diameter_mm) or profile_diameter_mm <= 0
    ):
        raise ValueError("profile_diameter_mm must be greater than zero.")
    if normalized_shape in ("rectangle", "rect") and (
        not math.isfinite(profile_width_mm)
        or not math.isfinite(profile_height_mm)
        or profile_width_mm <= 0
        or profile_height_mm <= 0
    ):
        raise ValueError(
            "Rectangle sweeps require positive profile_width_mm and "
            "profile_height_mm values."
        )
    normalized_orientation = str(profile_orientation).strip().lower()
    orientation_aliases = {
        "normal_to_path": "normal",
        "perpendicular": "normal",
        "parallel_to_profile": "parallel",
    }
    normalized_orientation = orientation_aliases.get(
        normalized_orientation, normalized_orientation
    )
    if normalized_orientation not in ("normal", "parallel"):
        raise ValueError("profile_orientation must be normal or parallel.")
    if not math.isfinite(twist_angle_deg):
        raise ValueError("twist_angle_deg must be finite.")
    if not math.isfinite(taper_angle_deg) or not -89 < taper_angle_deg < 89:
        raise ValueError("taper_angle_deg must be finite and between -89 and 89.")
    if normalized_orientation == "parallel" and (
        twist_angle_deg or taper_angle_deg
    ):
        raise ValueError(
            "twist_angle_deg and taper_angle_deg require normal orientation."
        )
    normalized_operation = str(operation).strip().lower()
    if normalized_operation not in ("new", "join", "cut", "intersect"):
        raise ValueError("Sweep operation must be new, join, cut, or intersect.")

    points_mm = _parse_3d_point_string(path_points)
    x_axis, y_axis = _normal_plane_axes(points_mm[0], points_mm[1])

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    points_cm = [
        tg.CreatePoint(*(_mm_to_cm(value) for value in point))
        for point in points_mm
    ]

    # Build one connected 3D sketch. CreatePath discovers every curve that is
    # connected to the supplied first curve, preserving the intended start.
    sketch3d = comp_def.Sketches3D.Add()
    work_points = [comp_def.WorkPoints.AddFixed(point) for point in points_cm]
    first_line = sketch3d.SketchLines3D.AddByTwoPoints(
        work_points[0], work_points[1], True
    )
    previous_line = first_line
    for index in range(2, len(work_points)):
        previous_line = sketch3d.SketchLines3D.AddByTwoPoints(
            previous_line.EndPoint, work_points[index], True
        )
    path = comp_def.Features.CreatePath(first_line)

    # A fixed construction plane is reliable for straight and curved path
    # starts. AddByNormalToCurve has curve-type restrictions in Inventor's
    # API, while AddFixed accepts an explicit orthonormal coordinate frame.
    profile_plane = comp_def.WorkPlanes.AddFixed(
        points_cm[0],
        tg.CreateUnitVector(*x_axis),
        tg.CreateUnitVector(*y_axis),
        True,
    )
    sketch2d = comp_def.Sketches.Add(profile_plane)
    centre = sketch2d.ModelToSketchSpace(points_cm[0])

    if normalized_shape == "circle":
        sketch2d.SketchCircles.AddByCenterRadius(
            centre, _mm_to_cm(profile_diameter_mm) / 2.0
        )
        profile_detail = f"circle D {profile_diameter_mm} mm"
    else:
        half_width = _mm_to_cm(profile_width_mm) / 2.0
        half_height = _mm_to_cm(profile_height_mm) / 2.0
        sketch2d.SketchLines.AddAsTwoPointRectangle(
            tg.CreatePoint2d(centre.X - half_width, centre.Y - half_height),
            tg.CreatePoint2d(centre.X + half_width, centre.Y + half_height),
        )
        profile_detail = f"rectangle {profile_width_mm} x {profile_height_mm} mm"
    profile = sketch2d.Profiles.AddForSolid()

    sweep_features = comp_def.Features.SweepFeatures
    sweep_definition = sweep_features.CreateSweepDefinition(
        _const.kPathSweepType,
        profile,
        path,
        _parse_feature_operation(normalized_operation),
    )
    orientation_map = {
        "normal": _const.kNormalToPath,
        "parallel": _const.kParallelToOriginalProfile,
    }
    sweep_definition.ProfileOrientation = orientation_map[normalized_orientation]
    if normalized_orientation == "normal":
        if twist_angle_deg:
            sweep_definition.TwistAngle = f"{twist_angle_deg} deg"
        if taper_angle_deg:
            sweep_definition.TaperAngle = f"{taper_angle_deg} deg"
    sweep_feature = sweep_features.Add(sweep_definition)

    return (
        f"Sweep '{sweep_feature.Name}' created with {profile_detail}, "
        f"{len(points_cm)} path points, {normalized_orientation} orientation, "
        f"twist {twist_angle_deg} degrees, taper {taper_angle_deg} degrees, "
        f"operation '{normalized_operation}'."
    )


@mcp.tool()
def loft(
    sections: str,
    operation: str = "new",
    closed: bool = False,
    merge_tangent_faces: bool = True,
) -> str:
    """Create a loft (German: Erhebung) through circle/rectangle sections.

    The legacy circle format remains supported: ``XY:50;30:40;60:30``.
    Structured sections use one of these forms (all dimensions in mm):
    ``plane|circle|diameter[|centre_x|centre_y]`` or
    ``plane|rectangle|width|height[|centre_x|centre_y]``.
    A numeric plane means an offset from XY; XY, XZ, YZ, offset work planes
    such as ``XY:30``, and named work planes are also accepted.
    """
    parsed_sections = _parse_loft_sections(sections)
    normalized_operation = str(operation).strip().lower()
    if normalized_operation not in ("new", "join", "cut", "intersect"):
        raise ValueError("Loft operation must be new, join, cut, or intersect.")
    if closed and len(parsed_sections) < 3:
        raise ValueError("A closed loft requires at least three sections.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    sections_coll = app.TransientObjects.CreateObjectCollection()

    section_descriptions = []
    for section in parsed_sections:
        plane_spec = section["plane"]
        try:
            height_mm = float(plane_spec)
            work_plane = comp_def.WorkPlanes.AddByPlaneAndOffset(
                comp_def.WorkPlanes.Item(3), _mm_to_cm(height_mm), True
            )
        except ValueError:
            work_plane = _resolve_work_plane(comp_def, plane_spec)

        sketch = comp_def.Sketches.Add(work_plane)
        centre = tg.CreatePoint2d(
            _mm_to_cm(section["center_x_mm"]),
            _mm_to_cm(section["center_y_mm"]),
        )
        if section["shape"] == "circle":
            sketch.SketchCircles.AddByCenterRadius(
                centre, _mm_to_cm(section["diameter_mm"]) / 2.0
            )
            detail = f"circle D {section['diameter_mm']} mm"
        else:
            half_width = _mm_to_cm(section["width_mm"]) / 2.0
            half_height = _mm_to_cm(section["height_mm"]) / 2.0
            sketch.SketchLines.AddAsTwoPointRectangle(
                tg.CreatePoint2d(centre.X - half_width, centre.Y - half_height),
                tg.CreatePoint2d(centre.X + half_width, centre.Y + half_height),
            )
            detail = (
                f"rectangle {section['width_mm']} x {section['height_mm']} mm"
            )
        profile = sketch.Profiles.AddForSolid()
        sections_coll.Add(profile)
        section_descriptions.append(f"{plane_spec}: {detail}")

    loft_def = comp_def.Features.LoftFeatures.CreateLoftDefinition(
        sections_coll, _parse_feature_operation(normalized_operation)
    )
    loft_def.Closed = bool(closed)
    loft_def.MergeTangentFaces = bool(merge_tangent_faces)
    loft_feature = comp_def.Features.LoftFeatures.Add(loft_def)

    return (
        f"Loft '{loft_feature.Name}' created through {len(parsed_sections)} "
        f"sections ({'; '.join(section_descriptions)}), "
        f"closed={bool(closed)}, merge_tangent_faces={bool(merge_tangent_faces)}, "
        f"operation '{normalized_operation}'."
    )


@mcp.tool()
def add_thread(
    face_index: int = 0,
    thread_standard: str = "ISO Metric Profile",
    thread_size: str = "M10x1.5",
    thread_class: str = "6g",
    depth_mm: float = 0.0,
) -> str:
    """
    Fuegt ein Gewinde auf einer zylindrischen Flaeche hinzu.

    Args:
        face_index:     Index der zylindrischen Flaeche (0 = auto-erkennen,
                        die erste zylindrische Flaeche wird genommen).
        thread_standard: Standard (z.B. "ISO Metric Profile",
                        "ANSI Unified Screw Threads").
        thread_size:    Gewindegroesse (z.B. "M10x1.5", "M20x2.5").
        thread_class:   Klasse (z.B. "6g", "6H", "2A").
        depth_mm:       Gewindetiefe in mm. 0 = Volle Laenge.
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    if comp_def.SurfaceBodies.Count == 0:
        raise RuntimeError("Kein Volumenkoerper vorhanden.")

    body = comp_def.SurfaceBodies.Item(1)

    # Zylindrische Flaeche finden.
    target_face = None
    if face_index > 0:
        if face_index > body.Faces.Count:
            raise ValueError(f"Flaechen-Index {face_index} ungueltig.")
        target_face = body.Faces.Item(face_index)
    else:
        # Auto-erkennen: erste zylindrische Flaeche.
        for i in range(1, body.Faces.Count + 1):
            face = body.Faces.Item(i)
            try:
                if face.SurfaceType == 5890:  # CylinderSurfaceType
                    target_face = face
                    break
            except Exception:
                continue

    if target_face is None:
        raise RuntimeError(
            "Keine zylindrische Flaeche gefunden. "
            "face_index angeben oder Zylinder erstellen."
        )

    # Startkante finden (Kante der Flaeche) - unterste Kante bevorzugen.
    start_edge = None
    for i in range(1, target_face.Edges.Count + 1):
        e = target_face.Edges.Item(i)
        try:
            z_val = e.StartVertex.Point.Z
            if start_edge is None or z_val < start_edge.StartVertex.Point.Z:
                start_edge = e
        except Exception:
            continue
    if start_edge is None:
        start_edge = target_face.Edges.Item(1)

    # ThreadInfo erstellen.
    try:
        thread_info = comp_def.Features.ThreadFeatures.CreateStandardThreadInfo(
            False, True, thread_standard, thread_size, thread_class
        )
    except Exception as exc:
        raise RuntimeError(
            f"CreateStandardThreadInfo fehlgeschlagen: {exc}. "
            f"Pruefe Standard '{thread_standard}', Groesse '{thread_size}', "
            f"Klasse '{thread_class}'."
        )

    # Thread erstellen.
    try:
        if depth_mm <= 0:
            comp_def.Features.ThreadFeatures.Add(
                target_face, start_edge, thread_info,
                False, False, "2 cm", 0,
            )
            art = "Gewinde (volle Laenge)"
        else:
            comp_def.Features.ThreadFeatures.Add(
                target_face, start_edge, thread_info,
                False, False, f"{_mm_to_cm(depth_mm)} cm", 0,
            )
            art = f"Gewinde (Tiefe {depth_mm} mm)"
    except Exception as exc:
        raise RuntimeError(
            f"ThreadFeatures.Add fehlgeschlagen: {exc}. "
            f"Flaeche Index={face_index}, Kante Index=1."
        )

    return (
        f"{art} erstellt: {thread_size} ({thread_standard}, "
        f"Klasse {thread_class})."
    )


@mcp.tool()
def create_slot(
    length_mm: float,
    width_mm: float,
    depth_mm: float,
    x_mm: float = 0.0,
    y_mm: float = 0.0,
) -> str:
    """
    Erzeugt eine Nut / einen Schlitz (rechteckiger Materialabtrag).
    Vereinfachte Version von extrude_cut mit sinnvollen Defaults.

    Args:
        length_mm: Laenge der Nut in X (mm).
        width_mm:  Breite der Nut in Y (mm).
        depth_mm:  Tiefe der Nut (mm).
        x_mm:      X-Position der linken unteren Ecke (mm, Standard 0).
        y_mm:      Y-Position der linken unteren Ecke (mm, Standard 0).
    """
    return extrude_cut(length_mm, width_mm, depth_mm, x_mm, y_mm)


@mcp.tool()
def create_3d_path(points: str) -> str:
    """
    Erzeugt eine 3D-Skizze aus verbundenen Linien (Pfad fuer Sweep/Loft).
    Die Skizze bleibt als 3D-Skizze bestehen und kann fuer spaetere
    Sweep/Loft-Operationen verwendet werden.

    Args:
        points: Kommagetrennte 3D-Punkte in mm.
                Format: "x1,y1,z1;x2,y2,z2;x3,y3,z3"
    """
    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition
    tg = app.TransientGeometry

    raw_points = [p.strip() for p in points.split(";") if p.strip()]
    if len(raw_points) < 2:
        raise ValueError("Mindestens 2 Punkte noetig.")

    points_cm = []
    for pt_str in raw_points:
        parts = pt_str.split(",")
        if len(parts) != 3:
            raise ValueError(f"Ungueltiger Punkt: '{pt_str}'. Erwartet 'x,y,z'.")
        x, y, z = [_mm_to_cm(float(v)) for v in parts]
        points_cm.append(tg.CreatePoint(x, y, z))

    sketch3d = comp_def.Sketches3D.Add()
    wp_list = []
    for p in points_cm:
        wp = comp_def.WorkPoints.AddFixed(p)
        wp_list.append(wp)

    line = sketch3d.SketchLines3D.AddByTwoPoints(wp_list[0], wp_list[1], True)
    for i in range(2, len(wp_list)):
        line = sketch3d.SketchLines3D.AddByTwoPoints(
            line.EndPoint, wp_list[i], True
        )

    return (
        f"3D-Pfad erstellt: {len(points_cm)} Punkte, "
        f"{len(points_cm) - 1} Linien-Segmente."
    )


# ===========================================================================
# MUSTER (PATTERN)  -  arbeitet auf der zuletzt erzeugten Bohrung
# ===========================================================================
def _last_hole(comp_def):
    """Liefert die zuletzt erzeugte Bohrung als Muster-Ausgangsfeature."""
    holes = comp_def.Features.HoleFeatures
    if holes.Count == 0:
        raise RuntimeError(
            "Keine Bohrung vorhanden. Muster arbeitet auf der letzten "
            "Bohrung - erst 'add_hole' aufrufen."
        )
    return holes.Item(holes.Count)


@mcp.tool()
def pattern_rectangular(
    x_count: int,
    x_spacing_mm: float,
    y_count: int = 1,
    y_spacing_mm: float = 0.0,
) -> str:
    """
    Erzeugt ein rechteckiges Muster der ZULETZT erstellten Bohrung entlang
    der X- und optional Y-Achse.

    Args:
        x_count:      Anzahl in X-Richtung (>=1).
        x_spacing_mm: Abstand in X (mm).
        y_count:      Anzahl in Y-Richtung (Standard 1).
        y_spacing_mm: Abstand in Y (mm, nur falls y_count > 1).
    """
    if x_count < 1 or y_count < 1:
        raise ValueError("Anzahlen muessen >= 1 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    parents = app.TransientObjects.CreateObjectCollection()
    parents.Add(_last_hole(comp_def))

    x_axis = comp_def.WorkAxes.Item(1)
    y_axis = comp_def.WorkAxes.Item(2)
    rect = comp_def.Features.RectangularPatternFeatures

    # Abstaende als Ausdruck mit Einheit (robust gegenueber Einheiten).
    x_spacing = f"{x_spacing_mm} mm"
    pdef = rect.CreateDefinition(parents, x_axis, True, x_count, x_spacing)
    if y_count > 1:
        pdef.YDirectionEntity = y_axis
        pdef.YCount = y_count
        pdef.YSpacing = f"{y_spacing_mm} mm"
    rect.AddByDefinition(pdef)

    return (
        f"Rechteckmuster erstellt: {x_count} x {y_count} "
        f"(X-Abstand {x_spacing_mm} mm, Y-Abstand {y_spacing_mm} mm)."
    )


@mcp.tool()
def pattern_circular(count: int, angle_deg: float = 360.0) -> str:
    """
    Erzeugt ein kreisfoermiges Muster der ZULETZT erstellten Bohrung um die
    Z-Achse.

    Args:
        count:     Anzahl der Elemente (>=2).
        angle_deg: Gesamtwinkel in Grad (360 = gleichmaessig im Vollkreis).
    """
    if count < 2:
        raise ValueError("Anzahl muss >= 2 sein.")

    app = _get_app()
    doc = _require_part_document(app)
    doc.Activate()
    comp_def = doc.ComponentDefinition

    parents = app.TransientObjects.CreateObjectCollection()
    parents.Add(_last_hole(comp_def))

    z_axis = comp_def.WorkAxes.Item(3)
    circ = comp_def.Features.CircularPatternFeatures
    # Add(ParentFeatures, AxisEntity, NaturalAxisDirection, Count, Angle, Fit)
    circ.Add(parents, z_axis, True, count, f"{angle_deg} deg", False)

    return f"Kreismuster erstellt: {count} Elemente ueber {angle_deg} grd."


# ===========================================================================
# BAUGRUPPEN (ASSEMBLIES)
# ===========================================================================
@mcp.tool()
def create_assembly(name: str = "Baugruppe1") -> str:
    """
    Erstellt eine neue, leere Baugruppe (.iam) und macht sie aktiv.

    Args:
        name: Anzeigename der Baugruppe.
    """
    app = _get_app()
    doc_type = _const.kAssemblyDocumentObject
    template = app.FileManager.GetTemplateFile(doc_type)
    doc = app.Documents.Add(doc_type, template, True)
    try:
        doc.DisplayName = name
    except Exception:
        pass
    return f"Neue Baugruppe '{name}' erstellt."


@mcp.tool()
def place_component(
    file_path: str,
    x_mm: float = 0.0,
    y_mm: float = 0.0,
    z_mm: float = 0.0,
) -> str:
    """
    Platziert ein Bauteil/eine Baugruppe an Position (x, y, z) in der aktiven
    Baugruppe. Hinweis: Es werden KEINE Abhaengigkeiten (Constraints) gesetzt,
    die Komponente wird nur positioniert. Die erste Komponente wird fixiert.

    Args:
        file_path: Pfad zur .ipt/.iam-Datei.
        x_mm:      X-Position (mm).
        y_mm:      Y-Position (mm).
        z_mm:      Z-Position (mm).
    """
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None or doc.DocumentType != _const.kAssemblyDocumentObject:
        raise RuntimeError(
            "Aktives Dokument ist keine Baugruppe. Erst 'create_assembly'."
        )
    asm_def = win32com.client.CastTo(doc, "AssemblyDocument").ComponentDefinition
    tg = app.TransientGeometry

    # Positionsmatrix mit Verschiebung erstellen.
    matrix = tg.CreateMatrix()
    matrix.SetTranslation(
        tg.CreateVector(_mm_to_cm(x_mm), _mm_to_cm(y_mm), _mm_to_cm(z_mm))
    )

    is_first = asm_def.Occurrences.Count == 0
    occ = asm_def.Occurrences.Add(file_path, matrix)
    if is_first:
        try:
            occ.Grounded = True
        except Exception:
            pass

    return (
        f"Komponente platziert: {occ.Name} bei ({x_mm}, {y_mm}, {z_mm}) mm"
        + (" (fixiert)" if is_first else "")
        + "."
    )


@mcp.tool()
def list_occurrences() -> list:
    """Listet die Komponenten (Occurrences) der aktiven Baugruppe auf."""
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None or doc.DocumentType != _const.kAssemblyDocumentObject:
        raise RuntimeError("Aktives Dokument ist keine Baugruppe.")
    asm_def = win32com.client.CastTo(doc, "AssemblyDocument").ComponentDefinition
    result = []
    for occ in asm_def.Occurrences:
        try:
            result.append({"name": occ.Name, "grounded": occ.Grounded})
        except Exception:
            continue
    return result


# ===========================================================================
# TECHNISCHE ZEICHNUNGEN (DRAWINGS / DWG)
# ===========================================================================
@mcp.tool()
def create_drawing(model_path: str = "", scale: float = 1.0) -> str:
    """
    Erstellt eine neue Zeichnung mit Standardansichten (Vorderansicht +
    Draufsicht + Seitenansicht + Iso) aus einem Modell.

    Args:
        model_path: Pfad zur .ipt/.iam-Datei. Leer = aktuell aktives Modell
                    verwenden (muss ein Bauteil/Baugruppe sein).
        scale:      Massstab der Ansichten (z. B. 1.0, 0.5, 2.0).
    """
    app = _get_app()

    # Modell bestimmen.
    if model_path:
        model = app.Documents.Open(model_path, False)
    else:
        model = app.ActiveDocument
        if model is None or model.DocumentType not in (
            _const.kPartDocumentObject,
            _const.kAssemblyDocumentObject,
        ):
            raise RuntimeError(
                "Kein Modell angegeben und aktives Dokument ist kein "
                "Bauteil/keine Baugruppe."
            )

    # Neue Zeichnung erstellen.
    doc_type = _const.kDrawingDocumentObject
    template = app.FileManager.GetTemplateFile(doc_type)
    draw_doc = win32com.client.CastTo(
        app.Documents.Add(doc_type, template, True), "DrawingDocument"
    )
    sheet = draw_doc.ActiveSheet
    tg = app.TransientGeometry

    style = _const.kHiddenLineRemovedDrawingViewStyle

    # Basisansicht (Vorderansicht) links unten.
    base_pt = tg.CreatePoint2d(12, 12)
    base_view = sheet.DrawingViews.AddBaseView(
        model, base_pt, scale, _const.kFrontViewOrientation, style
    )

    # Projizierte Ansichten: Draufsicht (oben), Seitenansicht (rechts),
    # Iso (rechts oben).
    sheet.DrawingViews.AddProjectedView(
        base_view, tg.CreatePoint2d(12, 24), style, scale
    )
    sheet.DrawingViews.AddProjectedView(
        base_view, tg.CreatePoint2d(26, 12), style, scale
    )
    sheet.DrawingViews.AddProjectedView(
        base_view, tg.CreatePoint2d(26, 24), style, scale
    )

    return (
        "Zeichnung mit 4 Ansichten erstellt (Vorder-, Drauf-, Seiten-, "
        f"Iso-Ansicht), Massstab {scale}."
    )


@mcp.tool()
def export_dwg(file_path: str) -> str:
    """
    Exportiert die aktive Zeichnung als DWG-Datei.

    Args:
        file_path: Zielpfad, z. B. C:/temp/zeichnung.dwg
    """
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None or doc.DocumentType != _const.kDrawingDocumentObject:
        raise RuntimeError(
            "Aktives Dokument ist keine Zeichnung. Erst 'create_drawing'."
        )
    addin = _get_translator(app, "dwg")
    _export_via_translator(app, doc, addin, file_path)
    return f"DWG-Export gespeichert: {file_path}"


# ===========================================================================
# SCREENSHOT
# ===========================================================================
mViewOrientationMap = None


def _get_orientation_map():
    """Lazy-Load der ViewOrientationType-Konstanten."""
    global mViewOrientationMap
    if mViewOrientationMap is None:
        mViewOrientationMap = {
            "front": _const.kFrontViewOrientation,
            "back": _const.kBackViewOrientation,
            "top": _const.kTopViewOrientation,
            "bottom": _const.kBottomViewOrientation,
            "left": _const.kLeftViewOrientation,
            "right": _const.kRightViewOrientation,
            "iso": _const.kIsoTopRightViewOrientation,
            "iso_topleft": _const.kIsoTopLeftViewOrientation,
            "iso_bottomright": _const.kIsoBottomRightViewOrientation,
            "iso_bottomleft": _const.kIsoBottomLeftViewOrientation,
        }
    return mViewOrientationMap


@mcp.tool()
def screenshot(
    file_path: str,
    width: int = 1920,
    height: int = 1080,
    orientation: str = "home",
) -> str:
    """
    Speichert einen Screenshot des aktuellen Inventor-Views als Bild.

    Zwei Modi:
      - "home": Nimmt den aktuellen View (nach Fit), einfach und schnell.
      - Beliebige Orientierung (front/back/top/bottom/left/right/iso):
        Erstellt eine Kamera mit der gewuenschten Ausrichtung, fittet
        auf das gesamte Modell und speichert das Bild.

    Args:
        file_path:   Zielpfad (PNG/BMP/JPG), z. B. "C:/temp/screenshot.png".
        width:       Breite in Pixeln (Standard 1920).
        height:      Hoehe in Pixeln (Standard 1080).
        orientation: "home" oder eine der Orientierungen:
                     "front", "back", "top", "bottom", "left", "right",
                     "iso", "iso_topleft", "iso_bottomright", "iso_bottomleft".
    """
    app = _get_app()
    doc = app.ActiveDocument
    if doc is None:
        raise RuntimeError("Kein Dokument geoeffnet.")

    orientation = orientation.lower().strip()

    if orientation == "home":
        # Variante 1: ActiveView (aktueller View).
        view = app.ActiveView
        try:
            view.Fit()
        except Exception:
            pass
        try:
            view.SaveAsBitmap(file_path, width, height)
        except Exception as exc:
            raise RuntimeError(
                f"Screenshot fehlgeschlagen: {exc}"
            )
        return f"Screenshot (ActiveView) gespeichert: {file_path}"

    # Variante 2: Camera mit definierter Orientierung.
    orientation_map = _get_orientation_map()
    if orientation not in orientation_map:
        raise ValueError(
            f"Unbekannte Orientierung '{orientation}'. "
            f"Erlaubt: 'home', {', '.join(sorted(orientation_map.keys()))}."
        )

    # ComponentDefinition bestimmen.
    try:
        part_doc = win32com.client.CastTo(doc, "PartDocument")
        comp_def = part_doc.ComponentDefinition
    except Exception:
        try:
            asm_doc = win32com.client.CastTo(doc, "AssemblyDocument")
            comp_def = asm_doc.ComponentDefinition
        except Exception:
            raise RuntimeError(
                "Kein Bauteil/Baugruppe geoeffnet. "
                "Nur Bauteile und Baugruppen erlauben screenshots."
            )

    cam = app.TransientObjects.CreateCamera()
    cam.SceneObject = comp_def
    cam.ViewOrientationType = orientation_map[orientation]
    cam.Fit()
    cam.ApplyWithoutTransition()

    try:
        cam.SaveAsBitmap(file_path, width, height)
    except Exception as exc:
        raise RuntimeError(
            f"Screenshot fehlgeschlagen: {exc}"
        )

    return (
        f"Screenshot ({orientation}) gespeichert: {file_path} "
        f"({width}x{height} px)."
    )


# ---------------------------------------------------------------------------
# Einstiegspunkt
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    # stdio-Transport ist der Standard fuer Claude Desktop.
    mcp.run(transport="stdio")