Skip to content

Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.

feat: implement multi-provider integration, persistent background event loop, and data redaction

A. Sam Mohammadc3e8e9c4ccf9
diff --git a/.gitignore b/.gitignore
index 9318866..03d5472 100644
--- a/.gitignore
+++ b/.gitignore
@@ -227,3 +227,9 @@ replace_dll.ps1
update_dll.ps1
INSTALL_NEW_DLL.txt
temp.json
+
+# Local proposed architecture / report MD files
+docs/0001-multi-provider-architecture.md
+docs/proposed-multi-workflow-architecture.md
+docs/agent-handover-prompt.md
+
diff --git a/packages/mcp-server-revit/pyproject.toml b/packages/mcp-server-revit/pyproject.toml
index d22eb2e..de9d48d 100644
--- a/packages/mcp-server-revit/pyproject.toml
+++ b/packages/mcp-server-revit/pyproject.toml
@@ -16,6 +16,8 @@ dependencies = [
"httpx>=0.24",
"python-dotenv>=1.0",
"mcp>=0.9.0",
+ "ifcopenshell>=0.7.0",
+ "networkx>=3.0",
]
[project.scripts]
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/jobs.py b/packages/mcp-server-revit/src/revit_mcp_server/jobs.py
new file mode 100644
index 0000000..cc7a740
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/jobs.py
@@ -0,0 +1,562 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import inspect
+import math
+import re
+import threading
+import uuid
+from collections import deque
+from concurrent.futures import Future as ConcurrentFuture
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Deque, Mapping, Sequence
+
+
+class JobStatus(str, Enum):
+ queued = "queued"
+ running = "running"
+ completed = "completed"
+ failed = "failed"
+ cancelled = "cancelled"
+
+
+def _utc_now() -> datetime:
+ return datetime.now(timezone.utc)
+
+
+def _isoformat(value: datetime | None) -> str | None:
+ if value is None:
+ return None
+ return value.isoformat().replace("+00:00", "Z")
+
+
+_SECRET_VALUE_RE = re.compile(
+ r"(?i)\b(api[_-]?key|token|secret|password|passwd|session|authorization)\b\s*[:=]\s*([^\s,;]+)"
+)
+_WINDOWS_PATH_RE = re.compile(r"(?<!\w)(?:[A-Za-z]:[\\/](?:[^\s\"'<>|]+[\\/])*[^\s\"'<>|]+)")
+_POSIX_PATH_RE = re.compile(r"(?:(?<=^)|(?<=[\s\"'(<\[]))(/(?:[^/\s]+/)*[^/\s]+)")
+
+
+def _sanitize_text(value: str) -> str:
+ sanitized = _SECRET_VALUE_RE.sub(lambda match: f"{match.group(1)}=<redacted>", value)
+ sanitized = _WINDOWS_PATH_RE.sub("<path>", sanitized)
+ sanitized = _POSIX_PATH_RE.sub("<path>", sanitized)
+ return sanitized
+
+
+def _is_secret_key(key: str) -> bool:
+ return bool(
+ re.search(r"(?i)(api[_-]?key|token|secret|password|passwd|session|authorization)", key)
+ )
+
+
+def _sanitize_public_value(value: Any) -> Any:
+ if value is None or isinstance(value, (bool, int, str)):
+ return _sanitize_text(value) if isinstance(value, str) else value
+ if isinstance(value, float):
+ return value if math.isfinite(value) else None
+ if isinstance(value, bytes):
+ return _sanitize_text(value.decode("utf-8", errors="replace"))
+ if isinstance(value, Path):
+ return _sanitize_text(value.name or "<path>")
+ if isinstance(value, Enum):
+ return _sanitize_public_value(value.value)
+ if dataclasses.is_dataclass(value):
+ return _sanitize_public_value(dataclasses.asdict(value))
+ model_dump = getattr(value, "model_dump", None)
+ if callable(model_dump):
+ return _sanitize_public_value(model_dump())
+ if isinstance(value, BaseException):
+ return {
+ "type": value.__class__.__name__,
+ "message": "Job failed",
+ }
+ if isinstance(value, Mapping):
+ sanitized: dict[str, Any] = {}
+ for raw_key, raw_value in value.items():
+ key = str(raw_key)
+ sanitized[key] = "<redacted>" if _is_secret_key(key) else _sanitize_public_value(raw_value)
+ return sanitized
+ if isinstance(value, (list, tuple, set, frozenset)):
+ return [_sanitize_public_value(item) for item in value]
+ if inspect.isawaitable(value):
+ return "<awaitable>"
+ return {"type": value.__class__.__name__}
+
+
+def _normalize_artifacts(
+ artifact: Any | None = None,
+ artifacts: Sequence[Any] | Mapping[str, Any] | Any | None = None,
+) -> list[dict[str, Any]]:
+ candidates: list[Any] = []
+ if artifact is not None:
+ candidates.append(artifact)
+ if artifacts is not None:
+ if isinstance(artifacts, Mapping):
+ candidates.append(artifacts)
+ elif isinstance(artifacts, (list, tuple, set, frozenset)):
+ candidates.extend(artifacts)
+ else:
+ candidates.append(artifacts)
+
+ normalized: list[dict[str, Any]] = []
+ for candidate in candidates:
+ payload = _sanitize_public_value(candidate)
+ if isinstance(payload, dict):
+ normalized.append(payload)
+ else:
+ normalized.append({"value": payload})
+ return normalized
+
+
+@dataclass(slots=True)
+class JobReference:
+ job_id: str
+ status: str
+ created_at: str
+ updated_at: str
+ started_at: str | None = None
+ finished_at: str | None = None
+ idempotency_key: str | None = None
+ progress: float | None = None
+ message: str | None = None
+ result: Any = None
+ error: dict[str, Any] | None = None
+ artifacts: list[dict[str, Any]] = field(default_factory=list)
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "job_id": self.job_id,
+ "status": self.status,
+ "created_at": self.created_at,
+ "updated_at": self.updated_at,
+ "started_at": self.started_at,
+ "finished_at": self.finished_at,
+ "idempotency_key": self.idempotency_key,
+ "progress": self.progress,
+ "message": self.message,
+ "result": self.result,
+ "error": self.error,
+ "artifacts": self.artifacts,
+ }
+
+ model_dump = to_dict
+
+
+JobResult = JobReference
+
+
+@dataclass(slots=True)
+class _JobRecord:
+ job_id: str
+ func: Callable[..., Any]
+ args: tuple[Any, ...]
+ kwargs: dict[str, Any]
+ accepts_context: bool
+ idempotency_key: str | None
+ created_at: datetime = field(default_factory=_utc_now)
+ updated_at: datetime = field(default_factory=_utc_now)
+ started_at: datetime | None = None
+ finished_at: datetime | None = None
+ status: JobStatus = JobStatus.queued
+ progress: float | None = None
+ message: str | None = None
+ result: Any = None
+ error: dict[str, Any] | None = None
+ artifacts: list[dict[str, Any]] = field(default_factory=list)
+ cancel_event: threading.Event = field(default_factory=threading.Event)
+ task: asyncio.Task[Any] | None = None
+ loop: asyncio.AbstractEventLoop | None = None
+
+ def snapshot(self) -> JobReference:
+ return JobReference(
+ job_id=self.job_id,
+ status=self.status.value,
+ created_at=_isoformat(self.created_at) or "",
+ updated_at=_isoformat(self.updated_at) or "",
+ started_at=_isoformat(self.started_at),
+ finished_at=_isoformat(self.finished_at),
+ idempotency_key=self.idempotency_key,
+ progress=self.progress,
+ message=self.message,
+ result=self.result,
+ error=self.error,
+ artifacts=list(self.artifacts),
+ )
+
+ @property
+ def terminal(self) -> bool:
+ return self.status in {
+ JobStatus.completed,
+ JobStatus.failed,
+ JobStatus.cancelled,
+ }
+
+
+@dataclass(slots=True)
+class JobContext:
+ job_id: str
+ _manager: "JobManager"
+ _loop: asyncio.AbstractEventLoop
+ _cancel_event: threading.Event
+
+ @property
+ def cancelled(self) -> bool:
+ return self._cancel_event.is_set()
+
+ async def update_progress(
+ self,
+ *,
+ progress: float | None = None,
+ message: str | None = None,
+ artifact: Any | None = None,
+ artifacts: Sequence[Any] | Mapping[str, Any] | Any | None = None,
+ ) -> JobReference | None:
+ return await self._manager.update_progress(
+ self.job_id,
+ progress=progress,
+ message=message,
+ artifact=artifact,
+ artifacts=artifacts,
+ )
+
+ def update_progress_nowait(
+ self,
+ *,
+ progress: float | None = None,
+ message: str | None = None,
+ artifact: Any | None = None,
+ artifacts: Sequence[Any] | Mapping[str, Any] | Any | None = None,
+ ) -> ConcurrentFuture[JobReference | None]:
+ return asyncio.run_coroutine_threadsafe(
+ self._manager.update_progress(
+ self.job_id,
+ progress=progress,
+ message=message,
+ artifact=artifact,
+ artifacts=artifacts,
+ ),
+ self._loop,
+ )
+
+ async def add_artifact(self, artifact: Any) -> JobReference | None:
+ return await self._manager.update_progress(self.job_id, artifact=artifact)
+
+ def add_artifact_nowait(self, artifact: Any) -> ConcurrentFuture[JobReference | None]:
+ return asyncio.run_coroutine_threadsafe(
+ self._manager.update_progress(self.job_id, artifact=artifact),
+ self._loop,
+ )
+
+
+class JobManager:
+ def __init__(
+ self,
+ *,
+ max_active_jobs: int = 64,
+ max_retained_jobs: int = 128,
+ max_artifacts_per_job: int = 16,
+ retention_ttl_seconds: float = 3600.0,
+ ) -> None:
+ if max_active_jobs < 0:
+ raise ValueError("max_active_jobs must be non-negative")
+ if max_retained_jobs < 0:
+ raise ValueError("max_retained_jobs must be non-negative")
+ if max_artifacts_per_job < 0:
+ raise ValueError("max_artifacts_per_job must be non-negative")
+ if retention_ttl_seconds < 0:
+ raise ValueError("retention_ttl_seconds must be non-negative")
+ self._bound_loop: asyncio.AbstractEventLoop | None = None
+ self._max_active_jobs = max_active_jobs
+ self._max_retained_jobs = max_retained_jobs
+ self._max_artifacts_per_job = max_artifacts_per_job
+ self._retention_ttl_seconds = retention_ttl_seconds
+ self._jobs: dict[str, _JobRecord] = {}
+ self._idempotency_index: dict[str, str] = {}
+ self._terminal_order: Deque[str] = deque()
+ self._lock = asyncio.Lock()
+ self._shutdown = False
+ self._shutdown_event = asyncio.Event()
+
+ async def submit(
+ self,
+ func: Callable[..., Any],
+ /,
+ *args: Any,
+ idempotency_key: str | None = None,
+ **kwargs: Any,
+ ) -> JobReference:
+ self._ensure_loop()
+ async with self._lock:
+ if self._shutdown:
+ raise RuntimeError("JobManager is shut down")
+ self._prune_locked()
+ if idempotency_key:
+ existing_id = self._idempotency_index.get(idempotency_key)
+ if existing_id:
+ existing = self._jobs.get(existing_id)
+ if existing is not None:
+ return existing.snapshot()
+ self._idempotency_index.pop(idempotency_key, None)
+ if self._active_count_locked() >= self._max_active_jobs:
+ raise RuntimeError("JobManager active job capacity reached")
+
+ job_id = uuid.uuid4().hex
+ record = _JobRecord(
+ job_id=job_id,
+ func=func,
+ args=args,
+ kwargs=dict(kwargs),
+ accepts_context=_accepts_context(func),
+ idempotency_key=idempotency_key,
+ )
+ loop = asyncio.get_running_loop()
+ record.loop = loop
+ task = loop.create_task(self._run_job(job_id))
+ record.task = task
+ self._jobs[job_id] = record
+ if idempotency_key:
+ self._idempotency_index[idempotency_key] = job_id
+ return record.snapshot()
+
+ async def get(self, job_id: str) -> JobReference | None:
+ self._ensure_loop()
+ async with self._lock:
+ self._prune_locked()
+ record = self._jobs.get(job_id)
+ return None if record is None else record.snapshot()
+
+ async def cancel(self, job_id: str) -> JobReference | None:
+ self._ensure_loop()
+ async with self._lock:
+ self._prune_locked()
+ record = self._jobs.get(job_id)
+ if record is None:
+ return None
+ if record.terminal:
+ return record.snapshot()
+ record.cancel_event.set()
+ record.status = JobStatus.cancelled
+ record.finished_at = _utc_now()
+ record.updated_at = record.finished_at
+ task = record.task
+ if task is not None and not task.done():
+ task.cancel()
+ self._mark_terminal_locked(record)
+ return record.snapshot()
+
+ async def update_progress(
+ self,
+ job_id: str,
+ *,
+ progress: float | None = None,
+ message: str | None = None,
+ artifact: Any | None = None,
+ artifacts: Sequence[Any] | Mapping[str, Any] | Any | None = None,
+ ) -> JobReference | None:
+ self._ensure_loop()
+ async with self._lock:
+ self._prune_locked()
+ record = self._jobs.get(job_id)
+ if record is None:
+ return None
+ if record.terminal:
+ return record.snapshot()
+ if progress is not None:
+ value = float(progress)
+ if not math.isfinite(value):
+ raise ValueError("progress must be finite")
+ record.progress = max(0.0, min(100.0, value))
+ if message is not None:
+ record.message = _sanitize_text(message)
+ new_artifacts = _normalize_artifacts(artifact=artifact, artifacts=artifacts)
+ if new_artifacts:
+ record.artifacts.extend(new_artifacts)
+ if len(record.artifacts) > self._max_artifacts_per_job:
+ if self._max_artifacts_per_job == 0:
+ record.artifacts.clear()
+ else:
+ record.artifacts[:] = record.artifacts[-self._max_artifacts_per_job :]
+ record.updated_at = _utc_now()
+ return record.snapshot()
+
+ async def shutdown(self, *, cancel_running: bool = False) -> None:
+ self._ensure_loop()
+ async with self._lock:
+ self._shutdown = True
+ active_tasks = [
+ record.task
+ for record in self._jobs.values()
+ if record.task is not None and not record.task.done()
+ ]
+ active_records = [
+ record
+ for record in self._jobs.values()
+ if record.task is not None and not record.task.done()
+ ]
+ if cancel_running:
+ for record in active_records:
+ record.cancel_event.set()
+ record.status = JobStatus.cancelled
+ record.finished_at = _utc_now()
+ record.updated_at = record.finished_at
+ record.task.cancel()
+ self._mark_terminal_locked(record)
+ if active_tasks:
+ await asyncio.gather(*active_tasks, return_exceptions=True)
+ async with self._lock:
+ self._prune_locked()
+ self._shutdown_event.set()
+
+ async def __aenter__(self) -> "JobManager":
+ return self
+
+ async def __aexit__(self, exc_type, exc, tb) -> None:
+ await self.shutdown()
+
+ async def _run_job(self, job_id: str) -> None:
+ try:
+ async with self._lock:
+ record = self._jobs.get(job_id)
+ if record is None:
+ return
+ if record.status == JobStatus.cancelled:
+ return
+ record.status = JobStatus.running
+ record.started_at = record.started_at or _utc_now()
+ record.updated_at = _utc_now()
+ context = JobContext(
+ job_id=record.job_id,
+ _manager=self,
+ _loop=record.loop or asyncio.get_running_loop(),
+ _cancel_event=record.cancel_event,
+ )
+ func = record.func
+ args = record.args
+ kwargs = dict(record.kwargs)
+ if record.accepts_context and "context" not in kwargs:
+ kwargs["context"] = context
+ result = await self._invoke(func, args, kwargs)
+ sanitized_result = _sanitize_public_value(result)
+ except asyncio.CancelledError:
+ async with self._lock:
+ record = self._jobs.get(job_id)
+ if record is not None:
+ record.cancel_event.set()
+ record.status = JobStatus.cancelled
+ if record.finished_at is None:
+ record.finished_at = _utc_now()
+ record.updated_at = _utc_now()
+ self._mark_terminal_locked(record)
+ return
+ except Exception as exc: # noqa: BLE001
+ async with self._lock:
+ record = self._jobs.get(job_id)
+ if record is None or record.status == JobStatus.cancelled:
+ return
+ record.status = JobStatus.failed
+ record.error = {
+ "type": exc.__class__.__name__,
+ "message": "Job failed",
+ }
+ record.finished_at = _utc_now()
+ record.updated_at = record.finished_at
+ self._mark_terminal_locked(record)
+ return
+
+ async with self._lock:
+ record = self._jobs.get(job_id)
+ if record is None:
+ return
+ if record.status == JobStatus.cancelled:
+ return
+ record.status = JobStatus.completed
+ record.result = sanitized_result
+ record.finished_at = _utc_now()
+ record.updated_at = record.finished_at
+ self._mark_terminal_locked(record)
+
+ async def _invoke(self, func: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+ if inspect.iscoroutinefunction(func):
+ return await func(*args, **kwargs)
+
+ loop = asyncio.get_running_loop()
+ result = await loop.run_in_executor(None, lambda: func(*args, **kwargs))
+ if inspect.isawaitable(result):
+ return await result
+ return result
+
+ def _mark_terminal_locked(self, record: _JobRecord) -> None:
+ if record.job_id not in self._terminal_order:
+ self._terminal_order.append(record.job_id)
+ self._prune_locked()
+
+ def _ensure_loop(self) -> None:
+ loop = asyncio.get_running_loop()
+ if self._bound_loop is None:
+ self._bound_loop = loop
+ return
+ if self._bound_loop is not loop:
+ raise RuntimeError(
+ "JobManager is bound to a different event loop; keep one persistent loop for this manager"
+ )
+
+ def _active_count_locked(self) -> int:
+ return sum(1 for record in self._jobs.values() if not record.terminal)
+
+ def _prune_locked(self) -> None:
+ now = _utc_now()
+ if self._max_retained_jobs == 0:
+ while self._terminal_order:
+ job_id = self._terminal_order.popleft()
+ record = self._jobs.get(job_id)
+ if record is None or not record.terminal:
+ continue
+ self._jobs.pop(job_id, None)
+ if record.idempotency_key:
+ current = self._idempotency_index.get(record.idempotency_key)
+ if current == job_id:
+ self._idempotency_index.pop(record.idempotency_key, None)
+ return
+
+ while self._terminal_order:
+ job_id = self._terminal_order[0]
+ record = self._jobs.get(job_id)
+ if record is None:
+ self._terminal_order.popleft()
+ continue
+ if not record.terminal:
+ self._terminal_order.popleft()
+ continue
+ age_seconds = (
+ (now - record.finished_at).total_seconds()
+ if record.finished_at is not None
+ else 0.0
+ )
+ over_age = age_seconds > self._retention_ttl_seconds
+ over_count = len(self._terminal_order) > self._max_retained_jobs
+ if not over_age and not over_count:
+ break
+ self._terminal_order.popleft()
+ self._jobs.pop(job_id, None)
+ if record.idempotency_key:
+ current = self._idempotency_index.get(record.idempotency_key)
+ if current == job_id:
+ self._idempotency_index.pop(record.idempotency_key, None)
+
+
+def _accepts_context(func: Callable[..., Any]) -> bool:
+ try:
+ signature = inspect.signature(func)
+ except (TypeError, ValueError):
+ return False
+ for parameter in signature.parameters.values():
+ if parameter.kind == inspect.Parameter.VAR_KEYWORD:
+ return True
+ if parameter.name == "context":
+ return True
+ return False
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py b/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py
index 6413d8e..6714a00 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/mcp_server.py
@@ -1,997 +1,134 @@
"""
-MCP Server for Revit - Enables Claude Desktop to control Revit through natural language.
+MCP Server for AEC - Dynamic multi-provider automation server.
"""
from __future__ import annotations
import asyncio
import json
+import logging
from typing import Any
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
-from .bridge.client import BridgeClient
from .config import config
from .errors import BridgeError
+from .providers import (
+ ProviderRegistry,
+ RevitProvider,
+ IfcProvider,
+ AECMapperProvider,
+ RhinoProvider,
+ SemanticGraphProvider,
+ SpeckleProvider,
+ AutodeskDataProvider,
+ JobProvider,
+)
+from .security.workspace import WorkspaceMonitor
+from .security.audit import redact_data
+from .jobs import JobManager
+
+logger = logging.getLogger(__name__)
# Initialize the MCP server
-app = Server("revit-mcp")
-
-# Initialize bridge client
-bridge = BridgeClient(config.bridge_url) if config.bridge_url else None
-
+app = Server("aec-model-bridge")
+
+# Create workspace monitor
+workspace = WorkspaceMonitor(config.allowed_directories)
+
+# Initialize registry and register providers
+registry = ProviderRegistry()
+registry.register(RevitProvider(workspace=workspace))
+registry.register(IfcProvider(workspace=workspace))
+registry.register(AECMapperProvider(workspace=workspace))
+
+# Initialize Job Manager and Job Provider
+job_manager = JobManager()
+registry.register(JobProvider(manager=job_manager))
+
+# Rhino Provider
+try:
+ registry.register(RhinoProvider(workspace=workspace))
+except Exception as e:
+ logger.warning("Could not initialize RhinoProvider: %s", e)
+
+# Semantic Graph Provider
+try:
+ registry.register(SemanticGraphProvider())
+except Exception as e:
+ logger.warning("Could not initialize SemanticGraphProvider: %s", e)
+
+# Speckle Provider
+try:
+ registry.register(SpeckleProvider())
+except Exception as e:
+ logger.warning("Could not initialize SpeckleProvider: %s. Please set SPECKLE_CLIENT_ID.", e)
+
+# Autodesk Data Provider
+try:
+ registry.register(AutodeskDataProvider())
+except Exception as e:
+ logger.warning("Could not initialize AutodeskDataProvider: %s. Please set APS_CLIENT_ID.", e)
@app.list_tools()
async def list_tools() -> list[Tool]:
- """List all available Revit tools."""
+ """List all available AEC tools from registered providers."""
return [
Tool(
- name="revit_health",
- description="Check if Revit is running and get status information",
- inputSchema={
- "type": "object",
- "properties": {},
- "required": []
- }
- ),
- Tool(
- name="revit_create_wall",
- description="Create a wall in Revit between two points",
- inputSchema={
- "type": "object",
- "properties": {
- "start_x": {"type": "number", "description": "Start point X coordinate in feet"},
- "start_y": {"type": "number", "description": "Start point Y coordinate in feet"},
- "start_z": {"type": "number", "description": "Start point Z coordinate in feet", "default": 0},
- "end_x": {"type": "number", "description": "End point X coordinate in feet"},
- "end_y": {"type": "number", "description": "End point Y coordinate in feet"},
- "end_z": {"type": "number", "description": "End point Z coordinate in feet", "default": 0},
- "height": {"type": "number", "description": "Wall height in feet", "default": 10},
- "level": {"type": "string", "description": "Level name (e.g., 'L1', 'L2')", "default": "L1"}
- },
- "required": ["start_x", "start_y", "end_x", "end_y"]
- }
- ),
- Tool(
- name="revit_create_floor",
- description="Create a floor in Revit with a rectangular or custom boundary",
- inputSchema={
- "type": "object",
- "properties": {
- "points": {
- "type": "array",
- "description": "Array of boundary points [{x, y, z}]. Minimum 3 points for a closed boundary.",
- "items": {
- "type": "object",
- "properties": {
- "x": {"type": "number"},
- "y": {"type": "number"},
- "z": {"type": "number", "default": 0}
- },
- "required": ["x", "y"]
- }
- },
- "level": {"type": "string", "description": "Level name", "default": "L1"}
- },
- "required": ["points"]
- }
- ),
- Tool(
- name="revit_create_roof",
- description="Create a roof in Revit",
- inputSchema={
- "type": "object",
- "properties": {
- "points": {
- "type": "array",
- "description": "Array of boundary points for the roof",
- "items": {
- "type": "object",
- "properties": {
- "x": {"type": "number"},
- "y": {"type": "number"},
- "z": {"type": "number"}
- }
- }
- },
- "level": {"type": "string", "description": "Level name"},
- "slope": {"type": "number", "description": "Roof slope", "default": 0.5}
- },
- "required": ["points", "level"]
- }
- ),
- Tool(
- name="revit_list_levels",
- description="List all levels in the Revit project",
- inputSchema={
- "type": "object",
- "properties": {},
- "required": []
- }
- ),
- Tool(
- name="revit_list_views",
- description="List all views in the Revit project",
- inputSchema={
- "type": "object",
- "properties": {},
- "required": []
- }
- ),
- Tool(
- name="revit_list_elements",
- description="List elements by category (Walls, Floors, Roofs, Doors, Windows, etc.)",
- inputSchema={
- "type": "object",
- "properties": {
- "category": {"type": "string", "description": "Category name (e.g., 'Walls', 'Floors', 'Doors')"}
- },
- "required": ["category"]
- }
- ),
- Tool(
- name="revit_get_document_info",
- description="Get information about the active Revit document",
- inputSchema={
- "type": "object",
- "properties": {},
- "required": []
- }
- ),
- Tool(
- name="revit_create_level",
- description="Create a new level in Revit",
- inputSchema={
- "type": "object",
- "properties": {
- "name": {"type": "string", "description": "Level name"},
- "elevation": {"type": "number", "description": "Elevation in feet"}
- },
- "required": ["name", "elevation"]
- }
- ),
- Tool(
- name="revit_save_document",
- description="Save the current Revit document",
- inputSchema={
- "type": "object",
- "properties": {
- "path": {"type": "string", "description": "File path to save to (optional for existing files)"}
- }
- }
- ),
- Tool(
- name="revit_create_grid",
- description="Create a grid line in Revit",
- inputSchema={
- "type": "object",
- "properties": {
- "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 0},
- "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 0},
- "name": {"type": "string"}
- },
- "required": ["start_x", "start_y", "end_x", "end_y"]
- }
- ),
- Tool(
- name="revit_create_room",
- description="Create a room at a specific point on a level",
- inputSchema={
- "type": "object",
- "properties": {
- "level": {"type": "string"},
- "x": {"type": "number"}, "y": {"type": "number"},
- "name": {"type": "string", "default": "Room"},
- "number": {"type": "string"}
- },
- "required": ["level", "x", "y"]
- }
- ),
- Tool(
- name="revit_delete_element",
- description="Delete an element by ID",
- inputSchema={
- "type": "object",
- "properties": {"element_id": {"type": "integer"}},
- "required": ["element_id"]
- }
- ),
- Tool(
- name="revit_place_family_instance",
- description="Place a family instance (e.g., furniture, equipment)",
- inputSchema={
- "type": "object",
- "properties": {
- "family_name": {"type": "string"}, "type_name": {"type": "string"},
- "level": {"type": "string"},
- "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}
- },
- "required": ["family_name", "type_name", "level", "x", "y"]
- }
- ),
- Tool(
- name="revit_place_door",
- description="Place a door in a wall",
- inputSchema={
- "type": "object",
- "properties": {
- "wall_id": {"type": "integer"},
- "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0},
- "family_name": {"type": "string"}, "type_name": {"type": "string"}
- },
- "required": ["wall_id", "x", "y"]
- }
- ),
- Tool(
- name="revit_place_window",
- description="Place a window in a wall",
- inputSchema={
- "type": "object",
- "properties": {
- "wall_id": {"type": "integer"},
- "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0},
- "family_name": {"type": "string"}, "type_name": {"type": "string"}
- },
- "required": ["wall_id", "x", "y"]
- }
- ),
- Tool(
- name="revit_list_families",
- description="List all loaded families and their types",
- inputSchema={"type": "object", "properties": {}}
- ),
- Tool(
- name="revit_create_floor_plan_view",
- description="Create a floor plan view for a level",
- inputSchema={
- "type": "object",
- "properties": {"level_name": {"type": "string"}, "view_name": {"type": "string"}},
- "required": ["level_name"]
- }
- ),
- Tool(
- name="revit_create_3d_view",
- description="Create a new 3D view",
- inputSchema={
- "type": "object",
- "properties": {"view_name": {"type": "string"}},
- "required": ["view_name"]
- }
- ),
- Tool(
- name="revit_create_section_view",
- description="Create a section view",
- inputSchema={
- "type": "object",
- "properties": {
- "view_name": {"type": "string"},
- "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number"},
- "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number"},
- "height": {"type": "number", "default": 10}
- },
- "required": ["start_x", "start_y", "end_x", "end_y"]
- }
- ),
- Tool(
- name="revit_get_element_parameters",
- description="Get all parameters of an element",
- inputSchema={
- "type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]
- }
- ),
- Tool(
- name="revit_set_parameter_value",
- description="Set a parameter value for an element",
- inputSchema={
- "type": "object",
- "properties": {
- "element_id": {"type": "integer"},
- "parameter_name": {"type": "string"},
- "value": {"type": ["string", "number", "boolean"]}
- },
- "required": ["element_id", "parameter_name", "value"]
- }
- ),
- Tool(
- name="revit_get_parameter_value",
- description="Get a specific parameter value",
- inputSchema={
- "type": "object",
- "properties": {"element_id": {"type": "integer"}, "parameter_name": {"type": "string"}},
- "required": ["element_id", "parameter_name"]
- }
- ),
- Tool(
- name="revit_list_shared_parameters",
- description="List shared parameters in the document",
- inputSchema={"type": "object", "properties": {}}
- ),
- Tool(
- name="revit_create_shared_parameter",
- description="Create a new shared parameter",
- inputSchema={
- "type": "object",
- "properties": {
- "name": {"type": "string"}, "group": {"type": "string"},
- "type": {"type": "string"}, "visible": {"type": "boolean"}
- },
- "required": ["name"]
- }
- ),
- Tool(
- name="revit_list_project_parameters",
- description="List project parameters",
- inputSchema={"type": "object", "properties": {}}
- ),
- Tool(
- name="revit_create_project_parameter",
- description="Create a new project parameter",
- inputSchema={
- "type": "object",
- "properties": {
- "name": {"type": "string"}, "category": {"type": "string"},
- "group": {"type": "string"}, "type": {"type": "string"}
- },
- "required": ["name", "category"]
- }
- ),
- Tool(
- name="revit_batch_set_parameters",
- description="Set a parameter value for multiple elements",
- inputSchema={
- "type": "object",
- "properties": {
- "element_ids": {"type": "array", "items": {"type": "integer"}},
- "parameter_name": {"type": "string"}, "value": {"type": ["string", "number"]}
- },
- "required": ["element_ids", "parameter_name", "value"]
- }
- ),
- Tool(
- name="revit_get_type_parameters",
- description="Get type parameters for an element",
- inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}
- ),
- Tool(
- name="revit_set_type_parameter",
- description="Set a type parameter value",
- inputSchema={
- "type": "object",
- "properties": {
- "element_id": {"type": "integer"},
- "parameter_name": {"type": "string"}, "value": {"type": ["string", "number"]}
- },
- "required": ["element_id", "parameter_name", "value"]
- }
- ),
- Tool(
- name="revit_list_sheets",
- description="List all sheets",
- inputSchema={"type": "object", "properties": {}}
- ),
- Tool(
- name="revit_create_sheet",
- description="Create a new sheet",
- inputSchema={
- "type": "object",
- "properties": {"name": {"type": "string"}, "number": {"type": "string"}, "titleblock_id": {"type": "integer"}},
- "required": ["name", "number"]
- }
- ),
- Tool(
- name="revit_delete_sheet",
- description="Delete a sheet",
- inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}}, "required": ["sheet_id"]}
- ),
- Tool(
- name="revit_place_viewport_on_sheet",
- description="Place a view on a sheet",
- inputSchema={
- "type": "object",
- "properties": {
- "sheet_id": {"type": "integer"}, "view_id": {"type": "integer"},
- "x": {"type": "number"}, "y": {"type": "number"}
- },
- "required": ["sheet_id", "view_id", "x", "y"]
- }
- ),
- Tool(
- name="revit_batch_create_sheets_from_csv",
- description="Create multiple sheets from a CSV file",
- inputSchema={
- "type": "object", "properties": {"csv_path": {"type": "string"}, "titleblock_name": {"type": "string"}},
- "required": ["csv_path"]
- }
- ),
- Tool(
- name="revit_populate_titleblock",
- description="Populate titleblock parameters",
- inputSchema={
- "type": "object", "properties": {"sheet_id": {"type": "integer"}, "parameters": {"type": "object"}},
- "required": ["sheet_id", "parameters"]
- }
- ),
- Tool(
- name="revit_list_titleblocks",
- description="List available titleblocks",
- inputSchema={"type": "object", "properties": {}}
- ),
- Tool(
- name="revit_get_sheet_info",
- description="Get detailed information about a sheet",
- inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}}, "required": ["sheet_id"]}
- ),
- Tool(
- name="revit_duplicate_sheet",
- description="Duplicate a sheet",
- inputSchema={
- "type": "object",
- "properties": {"sheet_id": {"type": "integer"}, "with_views": {"type": "boolean"}, "duplicate_option": {"type": "string"}},
- "required": ["sheet_id"]
- }
- ),
- Tool(
- name="revit_renumber_sheets",
- description="Batch renumber sheets",
- inputSchema={
- "type": "object", "properties": {"prefix": {"type": "string"}, "start_number": {"type": "integer"}},
- "required": ["start_number"]
- }
- ),
- # Batch 2: Selection
- Tool(name="revit_get_selection", description="Get currently selected element IDs", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_set_selection", description="Set selection by element IDs", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}}, "required": ["element_ids"]}),
- # Batch 2: Annotation
- Tool(name="revit_create_text_note", description="Create a text note", inputSchema={"type": "object", "properties": {"text": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "view_id": {"type": "integer"}}, "required": ["text", "x", "y"]}),
- Tool(name="revit_create_tag", description="Tag an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "view_id": {"type": "integer"}}, "required": ["element_id", "x", "y"]}),
- # Batch 2: Structure
- Tool(name="revit_create_column", description="Create structural column", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}}, "required": ["family_name", "type_name", "level", "x", "y"]}),
- Tool(name="revit_create_beam", description="Create structural beam", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}}, "required": ["family_name", "type_name", "level", "start_x", "start_y", "end_x", "end_y"]}),
- Tool(name="revit_create_foundation", description="Create foundation", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["family_name", "type_name", "level", "x", "y"]}),
- # Batch 2: MEP
- Tool(name="revit_create_duct", description="Create duct", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "z": {"type": "number", "default": 10}, "system_type": {"type": "string"}, "duct_type": {"type": "string"}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
- Tool(name="revit_create_pipe", description="Create pipe", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "z": {"type": "number", "default": 0}, "system_type": {"type": "string"}, "pipe_type": {"type": "string"}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
- # Batch 2: Helpers
- Tool(name="revit_get_categories", description="List Revit categories", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_get_element_type", description="Find element types/families", inputSchema={"type": "object", "properties": {"category_name": {"type": "string"}, "family_name": {"type": "string"}}, "required": ["category_name"]}),
- # Batch 2: Remaining Existing
- Tool(name="revit_close_document", description="Close active document", inputSchema={"type": "object", "properties": {"save_changes": {"type": "boolean", "default": False}}}),
- Tool(name="revit_create_new_document", description="Create new project", inputSchema={"type": "object", "properties": {"template_path": {"type": "string"}}}),
- Tool(name="revit_export_dwg", description="Export view to DWG", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}}, "required": ["view_id", "output_path"]}),
- Tool(name="revit_export_ifc", description="Export to IFC", inputSchema={"type": "object", "properties": {"output_path": {"type": "string"}}, "required": ["output_path"]}),
- Tool(name="revit_export_navisworks", description="Export to NWC", inputSchema={"type": "object", "properties": {"output_path": {"type": "string"}}, "required": ["output_path"]}),
- Tool(name="revit_export_image", description="Export view to Image", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}, "width": {"type": "integer"}, "height": {"type": "integer"}}, "required": ["view_id", "output_path"]}),
- Tool(name="revit_render_3d", description="Render 3D view to image", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}, "quality": {"type": "string", "enum": ["Draft", "Medium", "High"]}}, "required": ["view_id", "output_path"]}),
- # Batch 3: Editing
- Tool(name="revit_move_element", description="Move an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["element_id", "x", "y"]}),
- Tool(name="revit_copy_element", description="Copy an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["element_id", "x", "y"]}),
- Tool(name="revit_rotate_element", description="Rotate an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "center_x": {"type": "number"}, "center_y": {"type": "number"}, "center_z": {"type": "number", "default": 0}, "angle_radians": {"type": "number"}}, "required": ["element_id", "center_x", "center_y", "angle_radians"]}),
- Tool(name="revit_mirror_element", description="Mirror an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "plane_origin_x": {"type": "number"}, "plane_origin_y": {"type": "number"}, "plane_origin_z": {"type": "number", "default": 0}, "plane_normal_x": {"type": "number"}, "plane_normal_y": {"type": "number"}, "plane_normal_z": {"type": "number", "default": 0}}, "required": ["element_id", "plane_origin_x", "plane_origin_y", "plane_normal_x", "plane_normal_y"]}),
- Tool(name="revit_pin_element", description="Pin an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
- Tool(name="revit_unpin_element", description="Unpin an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
- # Batch 3: Worksharing
- Tool(name="revit_sync_to_central", description="Sync to central model", inputSchema={"type": "object", "properties": {"comment": {"type": "string"}, "relinquish": {"type": "boolean", "default": True}}}),
- Tool(name="revit_relinquish_all", description="Relinquish all elements and worksets", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_get_worksets", description="Get all worksets", inputSchema={"type": "object", "properties": {}}),
- # Batch 3: Schedules & Geo
- Tool(name="revit_create_schedule", description="Create a schedule", inputSchema={"type": "object", "properties": {"category_name": {"type": "string"}, "name": {"type": "string"}}, "required": ["category_name", "name"]}),
- Tool(name="revit_get_schedule_data", description="Get schedule data", inputSchema={"type": "object", "properties": {"schedule_id": {"type": "integer"}}, "required": ["schedule_id"]}),
- Tool(name="revit_get_element_bounding_box", description="Get element bounding box", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
- # Batch 4: Phasing
- Tool(name="revit_get_phases", description="Get project phases", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_get_phase_filters", description="Get phase filters", inputSchema={"type": "object", "properties": {}}),
- # Batch 4: Design Options
- Tool(name="revit_get_design_options", description="Get design options", inputSchema={"type": "object", "properties": {}}),
- # Batch 4: Groups
- Tool(name="revit_create_group", description="Create a group", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "name": {"type": "string"}}, "required": ["element_ids", "name"]}),
- Tool(name="revit_ungroup", description="Ungroup a group", inputSchema={"type": "object", "properties": {"group_id": {"type": "integer"}}, "required": ["group_id"]}),
- Tool(name="revit_get_group_members", description="Get group members", inputSchema={"type": "object", "properties": {"group_id": {"type": "integer"}}, "required": ["group_id"]}),
- # Batch 4: Links
- Tool(name="revit_get_rvt_links", description="Get RVT links", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_get_link_instances", description="Get link instances", inputSchema={"type": "object", "properties": {}}),
- # Batch 5: Advanced MEP & Engineering
- Tool(name="revit_create_conduit", description="Create electrical conduit", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 10}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 10}, "diameter": {"type": "number", "default": 0.0625}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
- Tool(name="revit_check_clashes", description="Check clashes between categories", inputSchema={"type": "object", "properties": {"category1": {"type": "string"}, "category2": {"type": "string"}, "tolerance": {"type": "number", "default": 0.01}}, "required": ["category1", "category2"]}),
- # Batch 6: Materials & Visuals
- Tool(name="revit_create_material", description="Create a new material with color and properties", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "color": {"type": "object", "properties": {"r": {"type": "integer"}, "g": {"type": "integer"}, "b": {"type": "integer"}}}, "transparency": {"type": "integer", "default": 0}, "shininess": {"type": "integer", "default": 50}, "smoothness": {"type": "integer", "default": 50}}, "required": ["name"]}),
- Tool(name="revit_set_element_material", description="Set material for an element or specific face", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "material_name": {"type": "string"}, "face_index": {"type": "integer", "description": "Optional face index for face-specific material"}}, "required": ["element_id", "material_name"]}),
- # Batch 7: Family Management
- Tool(name="revit_convert_to_group", description="Convert elements into a group", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "name": {"type": "string"}}, "required": ["element_ids"]}),
- Tool(name="revit_edit_family", description="Open a family for editing", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "family_symbol_id": {"type": "integer"}, "family_instance_id": {"type": "integer"}}, "required": []}),
- # Batch 8: High-Value Documentation & Analysis
- Tool(name="revit_create_dimension", description="Create linear dimension between elements", inputSchema={"type": "object", "properties": {"start_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "end_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "element1_id": {"type": "integer"}, "element2_id": {"type": "integer"}}, "required": ["start_point", "end_point", "element1_id", "element2_id"]}),
- Tool(name="revit_get_revision_sequences", description="Get list of revision sequences", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_tag_all_in_view", description="Tag all elements of a category in view", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
- Tool(name="revit_get_view_templates", description="Get list of view templates", inputSchema={"type": "object", "properties": {}}),
- Tool(name="revit_apply_view_template", description="Apply view template to a view", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "template_id": {"type": "integer"}}, "required": ["view_id", "template_id"]}),
- Tool(name="revit_calculate_material_quantities", description="Calculate material volumes for a category", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
- Tool(name="revit_get_warnings", description="Get current project warnings", inputSchema={"type": "object", "properties": {}}),
- # Batch 9: Universal Reflection Bridge (10k+ Tools)
- Tool(name="revit_invoke_method", description="Invoke any Revit API method dynamically using Reflection", inputSchema={"type": "object", "properties": {"class_name": {"type": "string"}, "method_name": {"type": "string"}, "arguments": {"type": "array", "items": {}}, "target_id": {"type": "string"}, "use_transaction": {"type": "boolean", "default": True}}, "required": ["class_name", "method_name", "arguments"]}),
- Tool(name="revit_reflect_get", description="Get any Revit property value dynamically", inputSchema={"type": "object", "properties": {"target_id": {"type": "string"}, "property_name": {"type": "string"}}, "required": ["target_id", "property_name"]}),
- Tool(name="revit_reflect_set", description="Set any Revit property value dynamically", inputSchema={"type": "object", "properties": {"target_id": {"type": "string"}, "property_name": {"type": "string"}, "value": {}}, "required": ["target_id", "property_name", "value"]}),
- # Batch 10: LLM Power Tools
- Tool(
- name="revit_execute_python",
- description=(
- "Execute arbitrary Python/IronPython code inside Revit with broad access to the public Revit API. "
- "Variables pre-injected: doc (Document), uidoc (UIDocument), uiapp (UIApplication), app (Application). "
- "Write output to stdout (print) or set __output__ = 'result string'. "
- "Use 'from Autodesk.Revit.DB import *' for API access. "
- "Execution is synchronous and is not sandboxed."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "script": {"type": "string", "description": "Python script to execute"}
- },
- "required": ["script"]
- }
- ),
- Tool(
- name="revit_change_element_type",
- description=(
- "Swap all instances of one element type to another type. "
- "Works for Walls, Doors, Windows, Floors, Roofs, Columns, Furniture, etc. "
- "Use revit_get_element_type or revit_list_elements first to find type IDs."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "source_type_id": {"type": "integer", "description": "Element type ID to replace (all instances)"},
- "target_type_id": {"type": "integer", "description": "Element type ID to change to"},
- "category": {"type": "string", "description": "Optional category filter (e.g. 'Walls', 'Doors') to limit scope"}
- },
- "required": ["source_type_id", "target_type_id"]
- }
- ),
- Tool(
- name="revit_get_elements_by_type",
- description=(
- "Get element IDs and key parameters, filtered by type, category, and/or level. "
- "Paginated — default 200 per call, max 500. Use offset for pagination. "
- "Specify 'fields' to limit returned data. Never crashes on large models."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "type_id": {"type": "integer", "description": "Filter by element type ID (optional)"},
- "category": {"type": "string", "description": "Filter by category name, e.g. 'Walls', 'Doors' (optional)"},
- "level": {"type": "string", "description": "Filter by level name, e.g. 'BG', 'L1' (optional)"},
- "fields": {
- "type": "array",
- "items": {"type": "string"},
- "description": "Fields to return: id always included. Options: name, category, type_id, level, length, area, volume"
- },
- "offset": {"type": "integer", "description": "Pagination offset (default 0)", "default": 0},
- "limit": {"type": "integer", "description": "Max results to return (default 200, max 500)", "default": 200}
- },
- "required": []
- }
- ),
- Tool(
- name="revit_batch_set_parameters_by_filter",
- description=(
- "Set a parameter value on all elements matching a filter (category, type, level, or parameter value). "
- "More powerful than revit_batch_set_parameters because you don't need to know element IDs first."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "filter": {
- "type": "object",
- "description": "Filter criteria to select elements",
- "properties": {
- "category": {"type": "string", "description": "Category name, e.g. 'Walls'"},
- "type_id": {"type": "integer", "description": "Element type ID filter"},
- "level": {"type": "string", "description": "Level name filter"},
- "parameter_filter": {
- "type": "object",
- "description": "Only include elements where this parameter equals this value",
- "properties": {
- "name": {"type": "string"},
- "value": {}
- },
- "required": ["name", "value"]
- }
- }
- },
- "parameter_name": {"type": "string", "description": "Name of the parameter to set"},
- "value": {"description": "Value to set (string, number, or boolean)"}
- },
- "required": ["filter", "parameter_name", "value"]
- }
- ),
- Tool(
- name="revit_replace_family_type",
- description=(
- "Replace all instances of one family/type combination with another, identified by name. "
- "Use this for doors, windows, furniture etc. when you know the family and type names."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "old_family": {"type": "string", "description": "Current family name (exact match, case-insensitive)"},
- "old_type": {"type": "string", "description": "Current type name"},
- "new_family": {"type": "string", "description": "Replacement family name"},
- "new_type": {"type": "string", "description": "Replacement type name"}
- },
- "required": ["old_family", "old_type", "new_family", "new_type"]
- }
- ),
- Tool(
- name="revit_get_element_geometry",
- description=(
- "Get geometric data for an element: location point or curve endpoints, bounding box, "
- "level, area, volume, and length. Coordinates are in Revit internal units (feet)."
- ),
- inputSchema={
- "type": "object",
- "properties": {
- "element_id": {"type": "integer", "description": "Element ID"}
- },
- "required": ["element_id"]
- }
- ),
+ name=t.name,
+ description=t.description,
+ inputSchema=t.input_schema
+ )
+ for t in registry.get_all_tools()
]
-
@app.call_tool()
async def call_tool(name: str, arguments: Any) -> list[TextContent]:
- """Execute a Revit tool."""
-
- if not bridge:
+ """Execute a registered AEC tool."""
+ provider = registry.lookup_tool_provider(name)
+ if not provider:
return [TextContent(
type="text",
- text="Error: Bridge not configured. Set MCP_REVIT_BRIDGE_URL in your .env file."
+ text=f"Error: Unknown tool '{name}'"
)]
try:
- # Map MCP tool names to Revit bridge tools
- tool_mapping = {
- # Existing Core Tools
- "revit_health": ("revit.health", {}),
- "revit_list_levels": ("revit.list_levels", {}),
- "revit_list_views": ("revit.list_views", {}),
- "revit_get_document_info": ("revit.get_document_info", {}),
- "revit_list_elements": ("revit.list_elements_by_category", {
- "category": arguments.get("category", "Walls")
- }),
- "revit_create_wall": ("revit.create_wall", {
- "start_point": {
- "x": arguments.get("start_x", 0),
- "y": arguments.get("start_y", 0),
- "z": arguments.get("start_z", 0)
- },
- "end_point": {
- "x": arguments.get("end_x", 0),
- "y": arguments.get("end_y", 0),
- "z": arguments.get("end_z", 0)
- },
- "height": arguments.get("height", 10),
- "level": arguments.get("level", "L1")
- }),
- "revit_create_floor": ("revit.create_floor", {
- "boundary_points": [
- {"x": p.get("x", 0), "y": p.get("y", 0), "z": p.get("z", 0)}
- for p in arguments.get("points", [])
- ],
- "level": arguments.get("level", "L1")
- }),
- "revit_create_roof": ("revit.create_roof", {
- "boundary_points": [
- {"x": p.get("x", 0), "y": p.get("y", 0), "z": p.get("z", 0)}
- for p in arguments.get("points", [])
- ],
- "level": arguments.get("level", "Level 2"),
- "slope": arguments.get("slope", 0.5)
- }),
- "revit_create_level": ("revit.create_level", {
- "name": arguments.get("name", "New Level"),
- "elevation": arguments.get("elevation", 10)
- }),
- "revit_save_document": ("revit.save_document", {
- "path": arguments.get("path", "")
- }),
- # Geometry (New)
- "revit_create_grid": ("revit.create_grid", {
- "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("start_z")},
- "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("end_z")},
- "name": arguments.get("name")
- }),
- "revit_create_room": ("revit.create_room", {
- "level": arguments.get("level"),
- "location_point": {"x": arguments.get("x"), "y": arguments.get("y"), "z": 0},
- "name": arguments.get("name"),
- "number": arguments.get("number")
- }),
- "revit_delete_element": ("revit.delete_element", {
- "element_id": arguments.get("element_id")
- }),
- # Placement (New)
- "revit_place_family_instance": ("revit.place_family_instance", {
- "family_name": arguments.get("family_name"),
- "type_name": arguments.get("type_name"),
- "level": arguments.get("level"),
- "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z")}
- }),
- "revit_place_door": ("revit.place_door", {
- "wall_id": arguments.get("wall_id"),
- "family_name": arguments.get("family_name"),
- "type_name": arguments.get("type_name"),
- "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z")}
- }),
- "revit_place_window": ("revit.place_window", {
- "wall_id": arguments.get("wall_id"),
- "family_name": arguments.get("family_name"),
- "type_name": arguments.get("type_name"),
- "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z")}
- }),
- "revit_list_families": ("revit.list_families", {}),
- # Views (New)
- "revit_create_floor_plan_view": ("revit.create_floor_plan_view", {
- "level_name": arguments.get("level_name"),
- "view_name": arguments.get("view_name")
- }),
- "revit_create_3d_view": ("revit.create_3d_view", {
- "view_name": arguments.get("view_name")
- }),
- "revit_create_section_view": ("revit.create_section_view", {
- "view_name": arguments.get("view_name"),
- "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("start_z")},
- "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("end_z")},
- "height": arguments.get("height")
- }),
- # Parameters (New)
- "revit_get_element_parameters": ("revit.get_element_parameters", {
- "element_id": arguments.get("element_id")
- }),
- "revit_set_parameter_value": ("revit.set_parameter_value", {
- "element_id": arguments.get("element_id"),
- "parameter_name": arguments.get("parameter_name"),
- "value": arguments.get("value")
- }),
- "revit_get_parameter_value": ("revit.get_parameter_value", {
- "element_id": arguments.get("element_id"),
- "parameter_name": arguments.get("parameter_name")
- }),
- "revit_list_shared_parameters": ("revit.list_shared_parameters", {}),
- "revit_create_shared_parameter": ("revit.create_shared_parameter", {
- "name": arguments.get("name"),
- "group": arguments.get("group", "General"),
- "type": arguments.get("type", "Text"),
- "visible": arguments.get("visible", True)
- }),
- "revit_list_project_parameters": ("revit.list_project_parameters", {}),
- "revit_create_project_parameter": ("revit.create_project_parameter", {
- "name": arguments.get("name"),
- "group": arguments.get("group", "General"),
- "type": arguments.get("type", "Text"),
- "category": arguments.get("category"),
- "visible": arguments.get("visible", True)
- }),
- "revit_batch_set_parameters": ("revit.batch_set_parameters", {
- "element_ids": arguments.get("element_ids"),
- "parameter_name": arguments.get("parameter_name"),
- "value": arguments.get("value")
- }),
- "revit_get_type_parameters": ("revit.get_type_parameters", {
- "element_id": arguments.get("element_id")
- }),
- "revit_set_type_parameter": ("revit.set_type_parameter", {
- "element_id": arguments.get("element_id"),
- "parameter_name": arguments.get("parameter_name"),
- "value": arguments.get("value")
- }),
- # Sheets (New)
- "revit_list_sheets": ("revit.list_sheets", {}),
- "revit_create_sheet": ("revit.create_sheet", {
- "name": arguments.get("name"),
- "number": arguments.get("number"),
- "titleblock_id": arguments.get("titleblock_id")
- }),
- "revit_delete_sheet": ("revit.delete_sheet", {
- "sheet_id": arguments.get("sheet_id")
- }),
- "revit_place_viewport_on_sheet": ("revit.place_viewport_on_sheet", {
- "sheet_id": arguments.get("sheet_id"),
- "view_id": arguments.get("view_id"),
- "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": 0}
- }),
- "revit_batch_create_sheets_from_csv": ("revit.batch_create_sheets_from_csv", {
- "csv_path": arguments.get("csv_path"),
- "titleblock_name": arguments.get("titleblock_name")
- }),
- "revit_populate_titleblock": ("revit.populate_titleblock", {
- "sheet_id": arguments.get("sheet_id"),
- "parameters": arguments.get("parameters")
- }),
- "revit_list_titleblocks": ("revit.list_titleblocks", {}),
- "revit_get_sheet_info": ("revit.get_sheet_info", {
- "sheet_id": arguments.get("sheet_id")
- }),
- "revit_duplicate_sheet": ("revit.duplicate_sheet", {
- "sheet_id": arguments.get("sheet_id"),
- "with_views": arguments.get("with_views", False),
- "duplicate_option": arguments.get("duplicate_option", "Duplicate")
- }),
- "revit_renumber_sheets": ("revit.renumber_sheets", {
- "prefix": arguments.get("prefix"),
- "start_number": arguments.get("start_number")
- }),
- # Batch 2: Selection
- "revit_get_selection": ("revit.get_selection", {}),
- "revit_set_selection": ("revit.set_selection", {"element_ids": arguments.get("element_ids")}),
- # Batch 2: Annotation
- "revit_create_text_note": ("revit.create_text_note", {"text": arguments.get("text"), "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": 0}, "view_id": arguments.get("view_id")}),
- "revit_create_tag": ("revit.create_tag", {"element_id": arguments.get("element_id"), "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": 0}, "view_id": arguments.get("view_id")}),
- # Batch 2: Structure
- "revit_create_column": ("revit.create_column", {"family_name": arguments.get("family_name"), "type_name": arguments.get("type_name"), "level": arguments.get("level"), "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": 0}}),
- "revit_create_beam": ("revit.create_beam", {"family_name": arguments.get("family_name"), "type_name": arguments.get("type_name"), "level": arguments.get("level"), "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": 0}, "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": 0}}),
- "revit_create_foundation": ("revit.create_foundation", {"family_name": arguments.get("family_name"), "type_name": arguments.get("type_name"), "level": arguments.get("level"), "location": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z", 0)}}),
- # Batch 2: MEP
- "revit_create_duct": ("revit.create_duct", {"level": arguments.get("level"), "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("z", 10)}, "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("z", 10)}, "system_type": arguments.get("system_type"), "duct_type": arguments.get("duct_type")}),
- "revit_create_pipe": ("revit.create_pipe", {"level": arguments.get("level"), "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("z", 0)}, "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("z", 0)}, "system_type": arguments.get("system_type"), "pipe_type": arguments.get("pipe_type")}),
- # Batch 2: Helpers
- "revit_get_categories": ("revit.get_categories", {}),
- "revit_get_element_type": ("revit.get_element_type", {"category_name": arguments.get("category_name"), "family_name": arguments.get("family_name")}),
- # Batch 2: Remaining Existing
- "revit_close_document": ("revit.close_document", {"save_changes": arguments.get("save_changes", False)}),
- "revit_create_new_document": ("revit.create_new_document", {"template_path": arguments.get("template_path")}),
- "revit_export_dwg": ("revit.export_dwg_by_view", {"view_id": arguments.get("view_id"), "output_path": arguments.get("output_path")}),
- "revit_export_ifc": ("revit.export_ifc_with_settings", {"output_path": arguments.get("output_path")}),
- "revit_export_navisworks": ("revit.export_navisworks", {"output_path": arguments.get("output_path")}),
- "revit_export_image": ("revit.export_image", {"view_id": arguments.get("view_id"), "output_path": arguments.get("output_path"), "width": arguments.get("width"), "height": arguments.get("height")}),
- "revit_render_3d": ("revit.render_3d_view", {"view_id": arguments.get("view_id"), "output_path": arguments.get("output_path"), "quality": arguments.get("quality", "Medium")}),
- # Batch 3: Editing
- "revit_move_element": ("revit.move_element", {"element_id": arguments.get("element_id"), "vector": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z", 0)}}),
- "revit_copy_element": ("revit.copy_element", {"element_id": arguments.get("element_id"), "vector": {"x": arguments.get("x"), "y": arguments.get("y"), "z": arguments.get("z", 0)}}),
- "revit_rotate_element": ("revit.rotate_element", {"element_id": arguments.get("element_id"), "axis_point": {"x": arguments.get("center_x"), "y": arguments.get("center_y"), "z": arguments.get("center_z", 0)}, "angle_radians": arguments.get("angle_radians")}),
- "revit_mirror_element": ("revit.mirror_element", {"element_id": arguments.get("element_id"), "plane_origin": {"x": arguments.get("plane_origin_x"), "y": arguments.get("plane_origin_y"), "z": arguments.get("plane_origin_z", 0)}, "plane_normal": {"x": arguments.get("plane_normal_x"), "y": arguments.get("plane_normal_y"), "z": arguments.get("plane_normal_z", 0)}}),
- "revit_pin_element": ("revit.pin_element", {"element_id": arguments.get("element_id")}),
- "revit_unpin_element": ("revit.unpin_element", {"element_id": arguments.get("element_id")}),
- # Batch 3: Worksharing
- "revit_sync_to_central": ("revit.sync_to_central", {"comment": arguments.get("comment", "Sync via MCP"), "relinquish": arguments.get("relinquish", True)}),
- "revit_relinquish_all": ("revit.relinquish_all", {}),
- "revit_get_worksets": ("revit.get_worksets", {}),
- # Batch 3: Schedules & Geo
- "revit_create_schedule": ("revit.create_schedule", {"category_name": arguments.get("category_name"), "name": arguments.get("name")}),
- "revit_get_schedule_data": ("revit.get_schedule_data", {"schedule_id": arguments.get("schedule_id")}),
- "revit_get_element_bounding_box": ("revit.get_element_bounding_box", {"element_id": arguments.get("element_id")}),
- # Batch 4: Phasing
- "revit_get_phases": ("revit.get_phases", {}),
- "revit_get_phase_filters": ("revit.get_phase_filters", {}),
- # Batch 4: Design Options
- "revit_get_design_options": ("revit.get_design_options", {}),
- # Batch 4: Groups
- "revit_create_group": ("revit.create_group", {"element_ids": arguments.get("element_ids"), "name": arguments.get("name")}),
- "revit_ungroup": ("revit.ungroup", {"group_id": arguments.get("group_id")}),
- "revit_get_group_members": ("revit.get_group_members", {"group_id": arguments.get("group_id")}),
- # Batch 4: Links
- "revit_get_rvt_links": ("revit.get_rvt_links", {}),
- "revit_get_link_instances": ("revit.get_link_instances", {}),
- # Batch 5: Advanced MEP & Engineering
- "revit_create_conduit": ("revit.create_conduit", {
- "level": arguments.get("level"),
- "start_point": {"x": arguments.get("start_x"), "y": arguments.get("start_y"), "z": arguments.get("start_z", 10)},
- "end_point": {"x": arguments.get("end_x"), "y": arguments.get("end_y"), "z": arguments.get("end_z", 10)},
- "diameter": arguments.get("diameter", 0.0625),
- "conduit_type": arguments.get("conduit_type")
- }),
- "revit_check_clashes": ("revit.check_clashes", {
- "category1": arguments.get("category1"),
- "category2": arguments.get("category2"),
- "tolerance": arguments.get("tolerance", 0.01)
- }),
- # Batch 6: Materials & Visuals
- "revit_create_material": ("revit.create_material", {
- "name": arguments.get("name"),
- "color": arguments.get("color"),
- "transparency": arguments.get("transparency", 0),
- "shininess": arguments.get("shininess", 50),
- "smoothness": arguments.get("smoothness", 50)
- }),
- "revit_set_element_material": ("revit.set_element_material", {
- "element_id": arguments.get("element_id"),
- "material_name": arguments.get("material_name"),
- "face_index": arguments.get("face_index")
- }),
- # Batch 7: Family Management
- "revit_convert_to_group": ("revit.convert_to_group", {
- "element_ids": arguments.get("element_ids"),
- "name": arguments.get("name")
- }),
- "revit_edit_family": ("revit.edit_family", {
- "family_name": arguments.get("family_name"),
- "family_symbol_id": arguments.get("family_symbol_id"),
- "family_instance_id": arguments.get("family_instance_id")
- }),
- # Batch 8: High-Value Documentation & Analysis
- "revit_create_dimension": ("revit.create_dimension", {
- "start_point": arguments.get("start_point"),
- "end_point": arguments.get("end_point"),
- "element1_id": arguments.get("element1_id"),
- "element2_id": arguments.get("element2_id")
- }),
- "revit_get_revision_sequences": ("revit.get_revision_sequences", {}),
- "revit_tag_all_in_view": ("revit.tag_all_in_view", {"category": arguments.get("category")}),
- "revit_get_view_templates": ("revit.get_view_templates", {}),
- "revit_apply_view_template": ("revit.apply_view_template", {
- "view_id": arguments.get("view_id"),
- "template_id": arguments.get("template_id")
- }),
- "revit_calculate_material_quantities": ("revit.calculate_material_quantities", {"category": arguments.get("category")}),
- "revit_get_warnings": ("revit.get_warnings", {}),
- # Batch 9: Universal Reflection Bridge
- "revit_invoke_method": ("revit.invoke_method", {
- "class_name": arguments.get("class_name"),
- "method_name": arguments.get("method_name"),
- "arguments": arguments.get("arguments"),
- "target_id": arguments.get("target_id"),
- "use_transaction": arguments.get("use_transaction", True)
- }),
- "revit_reflect_get": ("revit.reflect_get", {
- "target_id": arguments.get("target_id"),
- "property_name": arguments.get("property_name")
- }),
- "revit_reflect_set": ("revit.reflect_set", {
- "target_id": arguments.get("target_id"),
- "property_name": arguments.get("property_name"),
- "value": arguments.get("value")
- }),
- # Batch 10: LLM Power Tools
- "revit_execute_python": ("revit.execute_python", {
- "script": arguments.get("script")
- }),
- "revit_change_element_type": ("revit.change_element_type", {
- "source_type_id": arguments.get("source_type_id"),
- "target_type_id": arguments.get("target_type_id"),
- "category": arguments.get("category")
- }),
- "revit_get_elements_by_type": ("revit.get_elements_by_type", {
- "type_id": arguments.get("type_id"),
- "category": arguments.get("category"),
- "level": arguments.get("level"),
- "fields": arguments.get("fields"),
- "offset": arguments.get("offset", 0),
- "limit": arguments.get("limit", 200)
- }),
- "revit_batch_set_parameters_by_filter": ("revit.batch_set_parameters_by_filter", {
- "filter": arguments.get("filter"),
- "parameter_name": arguments.get("parameter_name"),
- "value": arguments.get("value")
- }),
- "revit_replace_family_type": ("revit.replace_family_type", {
- "old_family": arguments.get("old_family"),
- "old_type": arguments.get("old_type"),
- "new_family": arguments.get("new_family"),
- "new_type": arguments.get("new_type")
- }),
- "revit_get_element_geometry": ("revit.get_element_geometry", {
- "element_id": arguments.get("element_id")
- }),
- }
-
- if name not in tool_mapping:
- return [TextContent(
- type="text",
- text=f"Error: Unknown tool '{name}'"
- )]
-
- bridge_tool, payload = tool_mapping[name]
-
- # Call the bridge
- result = bridge.call_tool(bridge_tool, payload)
+ # Check if deferred execution is requested.
+ run_async = False
+ idempotency_key = None
+ if isinstance(arguments, dict):
+ args_copy = dict(arguments)
+ run_async = args_copy.pop("run_async", False)
+ if isinstance(run_async, str):
+ run_async = run_async.lower() in ("true", "1", "yes")
+ run_async = bool(run_async)
+ idempotency_key = args_copy.get("idempotency_key")
+
+ if run_async:
+ async def run_tool_job(context=None):
+ return await provider.execute_tool(name, arguments)
+
+ job_ref = await job_manager.submit(
+ run_tool_job,
+ idempotency_key=idempotency_key
+ )
+ response_text = f"✓ Job {job_ref.job_id} queued successfully\n\n"
+ response_text += f"Result:\n{json.dumps(job_ref.to_dict(), indent=2)}"
+ return [TextContent(type="text", text=response_text)]
+
+ # Execute the tool on the provider
+ result = await provider.execute_tool(name, arguments)
+ redacted_result = redact_data(result)
# Format the response
response_text = f"✓ {name} executed successfully\n\n"
- response_text += f"Result:\n{json.dumps(result, indent=2)}"
+ response_text += f"Result:\n{json.dumps(redacted_result, indent=2)}"
return [TextContent(type="text", text=response_text)]
except BridgeError as e:
- error_msg = f"Revit Bridge Error: {str(e)}\n\n"
+ error_msg = f"Revit Bridge Error: {redact_data(str(e))}\n\n"
error_msg += "Make sure:\n"
error_msg += "1. Revit is running\n"
error_msg += "2. A project is open in Revit\n"
@@ -1003,19 +140,20 @@ async def call_tool(name: str, arguments: Any) -> list[TextContent]:
except Exception as e:
return [TextContent(
type="text",
- text=f"Error: {str(e)}"
+ text=f"Error: {redact_data(str(e))}"
)]
-
async def main():
"""Run the MCP server."""
- async with stdio_server() as (read_stream, write_stream):
- await app.run(
- read_stream,
- write_stream,
- app.create_initialization_options()
- )
-
+ try:
+ async with stdio_server() as (read_stream, write_stream):
+ await app.run(
+ read_stream,
+ write_stream,
+ app.create_initialization_options()
+ )
+ finally:
+ await job_manager.shutdown(cancel_running=True)
def run_mcp_server():
"""Entry point for running the MCP server."""
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py
new file mode 100644
index 0000000..9c040b7
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/__init__.py
@@ -0,0 +1,25 @@
+from .base import AECProvider, ProviderTool
+from .registry import ProviderRegistry
+from .revit import RevitProvider
+from .ifc import IfcProvider
+from .fake import FakeProvider
+from .identity_mapper import AECMapperProvider
+from .rhino import RhinoProvider
+from .graph import SemanticGraphProvider
+from .cloud import SpeckleProvider, AutodeskDataProvider
+from .job_provider import JobProvider
+
+__all__ = [
+ "AECProvider",
+ "ProviderTool",
+ "ProviderRegistry",
+ "RevitProvider",
+ "IfcProvider",
+ "FakeProvider",
+ "AECMapperProvider",
+ "RhinoProvider",
+ "SemanticGraphProvider",
+ "SpeckleProvider",
+ "AutodeskDataProvider",
+ "JobProvider",
+]
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/base.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/base.py
new file mode 100644
index 0000000..262487a
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/base.py
@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List
+from pydantic import BaseModel, Field
+
+class ProviderTool(BaseModel):
+ name: str
+ description: str
+ input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
+
+ class Config:
+ populate_by_name = True
+ populate_by_field_name = True # Support both for older Pydantic compatibility if needed
+
+class AECProvider(ABC):
+ @abstractmethod
+ def get_identity(self) -> str:
+ """Return the unique identifier for the provider (e.g. 'revit', 'ifc')."""
+ pass
+
+ @abstractmethod
+ def get_capabilities(self) -> List[ProviderTool]:
+ """Return the list of tools supported by this provider."""
+ pass
+
+ @abstractmethod
+ async def check_health(self) -> Dict[str, Any]:
+ """Check the health status of the provider/connection."""
+ pass
+
+ @abstractmethod
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ """Execute a tool with the given name and arguments.
+
+ Args:
+ name: The name of the tool to execute.
+ arguments: The inputs to pass to the tool.
+
+ Returns:
+ A dict containing the execution results.
+ """
+ pass
+
+ @abstractmethod
+ async def shutdown(self) -> None:
+ """Perform cleanup or disconnect from resources."""
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/cloud.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/cloud.py
new file mode 100644
index 0000000..a2b6c15
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/cloud.py
@@ -0,0 +1,857 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import os
+import re
+import secrets
+import time
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Mapping
+from urllib.parse import quote, urlencode, urlparse
+
+import httpx
+from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator
+
+from .base import AECProvider, ProviderTool
+
+CredentialCallback = Callable[[str], str | None] | Callable[[str], Awaitable[str | None]]
+SpeckleMergeBuilder = Callable[[Dict[str, Any]], Dict[str, Any]]
+
+WINDOWS_PATH_PATTERN = re.compile(r"^[A-Za-z]:\\")
+POSIX_PATH_PATTERN = re.compile(r"^/(?:Users|home|tmp|var|etc|opt|srv|mnt|Volumes)/")
+WINDOWS_PATH_EMBEDDED_PATTERN = re.compile(r"[A-Za-z]:\\(?:[^\\/:*?\"<>|\r\n]+\\)*[^\\/:*?\"<>|\r\n]*")
+POSIX_PATH_EMBEDDED_PATTERN = re.compile(r"/(?:Users|home|tmp|var|etc|opt|srv|mnt|Volumes)(?:/[^\s\"']+)*")
+LOCALHOST_HOSTS = {"localhost", "127.0.0.1", "::1"}
+IFC_GUID_PATTERN = re.compile(r"^[0-9A-Za-z_$]{22}$")
+
+
+def _is_sensitive_key(key: str) -> bool:
+ normalized = re.sub(r"[^a-z0-9]", "", key.strip().lower())
+ return normalized in {
+ "authorization",
+ "accesstoken",
+ "refreshtoken",
+ "idtoken",
+ "token",
+ "password",
+ "clientsecret",
+ "secret",
+ "codeverifier",
+ "apikey",
+ "authorizationcode",
+ "code",
+ }
+
+
+def _looks_like_local_path(value: str) -> bool:
+ return bool(WINDOWS_PATH_PATTERN.match(value) or POSIX_PATH_PATTERN.match(value))
+
+
+def _redact_text(value: str) -> str:
+ if _looks_like_local_path(value):
+ return "<redacted-path>"
+ redacted = WINDOWS_PATH_EMBEDDED_PATTERN.sub("<redacted-path>", value)
+ redacted = POSIX_PATH_EMBEDDED_PATTERN.sub("<redacted-path>", redacted)
+ return redacted
+
+
+def _sanitize(value: Any, key: str | None = None) -> Any:
+ if key and _is_sensitive_key(key):
+ return "<redacted>"
+ if isinstance(value, Mapping):
+ return {item_key: _sanitize(item_value, item_key) for item_key, item_value in value.items()}
+ if isinstance(value, list):
+ return [_sanitize(item) for item in value]
+ if isinstance(value, tuple):
+ return tuple(_sanitize(item) for item in value)
+ if isinstance(value, str):
+ return _redact_text(value)
+ return value
+
+
+def _sanitize_headers(headers: Mapping[str, Any]) -> Dict[str, Any]:
+ return {key: _sanitize(value, key) for key, value in headers.items()}
+
+
+def _validate_https_url(url: str, *, allow_localhost_http: bool = False, label: str = "url") -> None:
+ parsed = urlparse(url)
+ if parsed.scheme == "https":
+ return
+ if allow_localhost_http and parsed.scheme == "http" and parsed.hostname in LOCALHOST_HOSTS:
+ return
+ raise ValueError(f"{label} must use HTTPS")
+
+
+def _b64url_sha256(value: str) -> str:
+ digest = hashlib.sha256(value.encode("utf-8")).digest()
+ return base64.urlsafe_b64encode(digest).decode("ascii").rstrip("=")
+
+
+def _json_headers(idempotency_key: str | None = None) -> Dict[str, str]:
+ headers = {"Accept": "application/json", "Content-Type": "application/json"}
+ if idempotency_key:
+ headers["Idempotency-Key"] = idempotency_key
+ return headers
+
+
+async def _maybe_await(value: Any) -> Any:
+ if hasattr(value, "__await__"):
+ return await value
+ return value
+
+
+class BCFViewpointMetadata(BaseModel):
+ model_config = ConfigDict(extra="forbid")
+
+ guid: str | None = None
+ snapshot_url: str | None = None
+ index: int | None = Field(default=None, ge=0)
+ is_external: bool | None = None
+ camera_view_point: Dict[str, float] | None = None
+
+
+class BCFTopicPayload(BaseModel):
+ model_config = ConfigDict(extra="forbid")
+
+ title: str = Field(min_length=1, max_length=255)
+ description: str = Field(min_length=1)
+ status: str | None = None
+ topic_type: str | None = Field(default=None, alias="type")
+ ifc_guid_refs: List[str] = Field(default_factory=list)
+ viewpoint: BCFViewpointMetadata | None = None
+
+ @field_validator("title", "description")
+ @classmethod
+ def _strip_required_text(cls, value: str) -> str:
+ trimmed = value.strip()
+ if not trimmed:
+ raise ValueError("value must not be empty")
+ return trimmed
+
+ @field_validator("ifc_guid_refs")
+ @classmethod
+ def _validate_ifc_guid_refs(cls, value: List[str]) -> List[str]:
+ for item in value:
+ if not IFC_GUID_PATTERN.match(item):
+ raise ValueError(f"Invalid IFC GUID reference: {item}")
+ return value
+
+
+@dataclass
+class OAuthTokenBundle:
+ access_token: str
+ refresh_token: str | None = None
+ expires_at: float | None = None
+ token_type: str = "Bearer"
+ scope: str | None = None
+
+ def is_expired(self, *, skew_seconds: int = 30) -> bool:
+ if self.expires_at is None:
+ return False
+ return time.time() >= (self.expires_at - skew_seconds)
+
+
+@dataclass
+class PendingOAuthState:
+ state: str
+ code_verifier: str
+ redirect_uri: str
+ created_at: float = field(default_factory=time.time)
+
+
+class OAuth2PKCETransport:
+ def __init__(
+ self,
+ *,
+ provider_name: str,
+ client_id: str | None = None,
+ client_secret: str | None = None,
+ redirect_uri: str,
+ auth_url: str,
+ token_url: str,
+ scopes: List[str] | None = None,
+ env_prefix: str | None = None,
+ credential_callback: CredentialCallback | None = None,
+ http_client: httpx.AsyncClient | None = None,
+ transport: httpx.AsyncBaseTransport | None = None,
+ timeout: float = 30.0,
+ allow_localhost_http: bool = False,
+ pending_state_ttl_seconds: int = 600,
+ max_pending_states: int = 32,
+ ) -> None:
+ self.provider_name = provider_name
+ self.env_prefix = env_prefix or provider_name.upper()
+ self.client_id = client_id or os.getenv(f"{self.env_prefix}_CLIENT_ID")
+ self._client_secret = client_secret or os.getenv(f"{self.env_prefix}_CLIENT_SECRET")
+ self.redirect_uri = redirect_uri
+ self.auth_url = auth_url
+ self.token_url = token_url
+ self.scopes = scopes or []
+ self.credential_callback = credential_callback
+ self.allow_localhost_http = allow_localhost_http
+ self.pending_state_ttl_seconds = pending_state_ttl_seconds
+ self.max_pending_states = max_pending_states
+ self._pending_states: Dict[str, PendingOAuthState] = {}
+ self._token_bundle: OAuthTokenBundle | None = None
+ self._owns_client = http_client is None
+ self._client = http_client or httpx.AsyncClient(transport=transport, timeout=timeout)
+
+ if not self.client_id:
+ raise ValueError(f"{self.provider_name} OAuth client_id is required")
+ if self.pending_state_ttl_seconds <= 0:
+ raise ValueError("pending_state_ttl_seconds must be positive")
+ if self.max_pending_states <= 0:
+ raise ValueError("max_pending_states must be positive")
+ _validate_https_url(self.auth_url, allow_localhost_http=allow_localhost_http, label="auth_url")
+ _validate_https_url(self.token_url, allow_localhost_http=allow_localhost_http, label="token_url")
+ _validate_https_url(self.redirect_uri, allow_localhost_http=allow_localhost_http, label="redirect_uri")
+
+ async def _get_secret(self) -> str | None:
+ if self._client_secret:
+ return self._client_secret
+ if self.credential_callback is None:
+ return None
+ secret = await _maybe_await(self.credential_callback("client_secret"))
+ if secret:
+ self._client_secret = secret
+ return self._client_secret
+
+ async def _get_refresh_token(self) -> str | None:
+ if self._token_bundle and self._token_bundle.refresh_token:
+ return self._token_bundle.refresh_token
+ if self.credential_callback is None:
+ return None
+ return await _maybe_await(self.credential_callback("refresh_token"))
+
+ def authorization_state(self) -> Dict[str, Any]:
+ self._prune_pending_states()
+ return {
+ "provider": self.provider_name,
+ "authorized": bool(self._token_bundle and not self._token_bundle.is_expired()),
+ "has_refresh_token": bool(self._token_bundle and self._token_bundle.refresh_token),
+ "expires_at": self._token_bundle.expires_at if self._token_bundle else None,
+ "pending_states": len(self._pending_states),
+ }
+
+ def build_authorization_url(self) -> Dict[str, str]:
+ self._prune_pending_states()
+ if len(self._pending_states) >= self.max_pending_states:
+ raise ValueError("Too many pending OAuth states; complete or wait for expiry before starting another flow")
+ state_value = secrets.token_urlsafe(24)
+ code_verifier = secrets.token_urlsafe(64)
+ self._pending_states[state_value] = PendingOAuthState(
+ state=state_value,
+ code_verifier=code_verifier,
+ redirect_uri=self.redirect_uri,
+ )
+ params = {
+ "response_type": "code",
+ "client_id": self.client_id,
+ "redirect_uri": self.redirect_uri,
+ "scope": " ".join(self.scopes),
+ "state": state_value,
+ "code_challenge": _b64url_sha256(code_verifier),
+ "code_challenge_method": "S256",
+ }
+ return {
+ "authorization_url": f"{self.auth_url}?{urlencode(params)}",
+ "state": state_value,
+ }
+
+ async def exchange_code(self, *, code: str, state: str) -> Dict[str, Any]:
+ self._prune_pending_states()
+ pending_state = self._pending_states.pop(state, None)
+ if pending_state is None:
+ raise ValueError("OAuth state validation failed")
+ payload = {
+ "grant_type": "authorization_code",
+ "client_id": self.client_id,
+ "code": code,
+ "redirect_uri": pending_state.redirect_uri,
+ "code_verifier": pending_state.code_verifier,
+ }
+ token_response = await self._post_token_form(payload)
+ return self._store_token_response(token_response)
+
+ async def refresh(self) -> Dict[str, Any]:
+ refresh_token = await self._get_refresh_token()
+ if not refresh_token:
+ raise ValueError("No refresh token is available")
+ payload = {
+ "grant_type": "refresh_token",
+ "client_id": self.client_id,
+ "refresh_token": refresh_token,
+ }
+ token_response = await self._post_token_form(payload)
+ return self._store_token_response(token_response)
+
+ async def get_access_token(self) -> str:
+ if self._token_bundle and not self._token_bundle.is_expired():
+ return self._token_bundle.access_token
+ refresh_token = await self._get_refresh_token()
+ if refresh_token:
+ await self.refresh()
+ if self._token_bundle and not self._token_bundle.is_expired():
+ return self._token_bundle.access_token
+ raise ValueError("Provider is not authenticated")
+
+ async def _post_token_form(self, payload: Dict[str, str]) -> Dict[str, Any]:
+ headers: Dict[str, str] = {"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}
+ client_secret = await self._get_secret()
+ if client_secret:
+ basic = base64.b64encode(f"{self.client_id}:{client_secret}".encode("utf-8")).decode("ascii")
+ headers["Authorization"] = f"Basic {basic}"
+ payload = dict(payload)
+ payload.pop("client_id", None)
+ try:
+ response = await self._client.post(self.token_url, data=payload, headers=headers)
+ response.raise_for_status()
+ return response.json()
+ except httpx.HTTPError as exc:
+ details = {
+ "provider": self.provider_name,
+ "url": self.token_url,
+ "headers": _sanitize_headers(headers),
+ "payload": _sanitize(payload),
+ }
+ raise RuntimeError(f"OAuth token request failed: {_sanitize(str(exc))}; details={json.dumps(details)}") from exc
+
+ def _store_token_response(self, payload: Mapping[str, Any]) -> Dict[str, Any]:
+ expires_in = payload.get("expires_in")
+ expires_at = time.time() + float(expires_in) if expires_in else None
+ self._token_bundle = OAuthTokenBundle(
+ access_token=str(payload["access_token"]),
+ refresh_token=str(payload["refresh_token"]) if payload.get("refresh_token") else None,
+ expires_at=expires_at,
+ token_type=str(payload.get("token_type", "Bearer")),
+ scope=str(payload["scope"]) if payload.get("scope") else None,
+ )
+ return self.authorization_state()
+
+ def _prune_pending_states(self) -> None:
+ cutoff = time.time() - self.pending_state_ttl_seconds
+ expired = [state for state, pending in self._pending_states.items() if pending.created_at < cutoff]
+ for state in expired:
+ self._pending_states.pop(state, None)
+
+ async def close(self) -> None:
+ if self._owns_client:
+ await self._client.aclose()
+
+
+class CloudProviderBase(AECProvider):
+ provider_identity = "cloud"
+
+ def __init__(
+ self,
+ *,
+ oauth: OAuth2PKCETransport,
+ http_client: httpx.AsyncClient | None = None,
+ transport: httpx.AsyncBaseTransport | None = None,
+ timeout: float = 30.0,
+ ) -> None:
+ self.oauth = oauth
+ self._owns_client = http_client is None
+ self._client = http_client or httpx.AsyncClient(transport=transport, timeout=timeout)
+ self._capabilities = self._build_capabilities()
+
+ def get_identity(self) -> str:
+ return self.provider_identity
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {
+ "status": "healthy",
+ "provider": self.provider_identity,
+ "auth": self.oauth.authorization_state(),
+ }
+
+ async def shutdown(self) -> None:
+ if self._owns_client:
+ await self._client.aclose()
+ await self.oauth.close()
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ normalized_name = name.replace(".", "_")
+ handler_name = self._tool_dispatch().get(normalized_name)
+ if handler_name is None:
+ raise ValueError(f"Unknown tool '{name}' on provider '{self.provider_identity}'")
+ try:
+ result = await getattr(self, handler_name)(arguments)
+ return _sanitize(result)
+ except ValidationError as exc:
+ raise ValueError(json.dumps(_sanitize(exc.errors()), default=str)) from exc
+ except Exception as exc:
+ raise type(exc)(_sanitize(str(exc))) from exc
+
+ def _tool_dispatch(self) -> Dict[str, str]:
+ raise NotImplementedError
+
+ def _build_capabilities(self) -> List[ProviderTool]:
+ raise NotImplementedError
+
+ async def _auth_headers(self) -> Dict[str, str]:
+ return {"Authorization": f"Bearer {await self.oauth.get_access_token()}"}
+
+ async def _get_json(self, url: str, *, params: Dict[str, Any] | None = None) -> Dict[str, Any]:
+ _validate_https_url(url, allow_localhost_http=self.oauth.allow_localhost_http, label="request_url")
+ headers = await self._auth_headers()
+ try:
+ response = await self._client.get(url, params=params, headers=headers)
+ response.raise_for_status()
+ return response.json()
+ except httpx.HTTPError as exc:
+ details = {"url": url, "params": params or {}, "headers": _sanitize_headers(headers)}
+ raise RuntimeError(f"GET request failed: {_sanitize(str(exc))}; details={json.dumps(details)}") from exc
+
+ async def _post_json(
+ self,
+ url: str,
+ *,
+ json_body: Dict[str, Any],
+ headers: Dict[str, str] | None = None,
+ ) -> Dict[str, Any]:
+ _validate_https_url(url, allow_localhost_http=self.oauth.allow_localhost_http, label="request_url")
+ auth_headers = await self._auth_headers()
+ merged_headers = {**auth_headers, **(headers or {})}
+ try:
+ response = await self._client.post(url, json=json_body, headers=merged_headers)
+ response.raise_for_status()
+ return response.json()
+ except httpx.HTTPError as exc:
+ details = {
+ "url": url,
+ "headers": _sanitize_headers(merged_headers),
+ "body": _sanitize(json_body),
+ }
+ raise RuntimeError(f"POST request failed: {_sanitize(str(exc))}; details={json.dumps(details)}") from exc
+
+
+class SpeckleProvider(CloudProviderBase):
+ provider_identity = "speckle"
+
+ def __init__(
+ self,
+ *,
+ host: str = "https://app.speckle.systems",
+ client_id: str | None = None,
+ client_secret: str | None = None,
+ redirect_uri: str = "https://localhost/callback",
+ scopes: List[str] | None = None,
+ credential_callback: CredentialCallback | None = None,
+ http_client: httpx.AsyncClient | None = None,
+ oauth_http_client: httpx.AsyncClient | None = None,
+ transport: httpx.AsyncBaseTransport | None = None,
+ oauth_transport: httpx.AsyncBaseTransport | None = None,
+ allow_localhost_http: bool = False,
+ oauth_pending_state_ttl_seconds: int = 600,
+ oauth_max_pending_states: int = 32,
+ merge_operation_builder: SpeckleMergeBuilder | None = None,
+ ) -> None:
+ _validate_https_url(host, allow_localhost_http=allow_localhost_http, label="speckle_host")
+ self.host = host.rstrip("/")
+ resolved_client_id = client_id or os.getenv("SPECKLE_CLIENT_ID")
+ self._merge_operation_builder = merge_operation_builder
+ oauth = OAuth2PKCETransport(
+ provider_name="speckle",
+ client_id=resolved_client_id,
+ client_secret=client_secret,
+ redirect_uri=redirect_uri,
+ auth_url=f"{self.host}/authn/verify/{resolved_client_id or ''}",
+ token_url=f"{self.host}/auth/token",
+ scopes=scopes or ["profile:read", "streams:read", "streams:write"],
+ env_prefix="SPECKLE",
+ credential_callback=credential_callback,
+ http_client=oauth_http_client,
+ transport=oauth_transport,
+ allow_localhost_http=allow_localhost_http,
+ pending_state_ttl_seconds=oauth_pending_state_ttl_seconds,
+ max_pending_states=oauth_max_pending_states,
+ )
+ super().__init__(oauth=oauth, http_client=http_client, transport=transport)
+ self.graphql_url = f"{self.host}/graphql"
+
+ def _tool_dispatch(self) -> Dict[str, str]:
+ return {
+ "speckle_health": "_tool_health",
+ "speckle_auth_status": "_tool_auth_status",
+ "speckle_oauth_start": "_tool_oauth_start",
+ "speckle_oauth_exchange_code": "_tool_oauth_exchange_code",
+ "speckle_oauth_refresh": "_tool_oauth_refresh",
+ "speckle_list_projects": "_tool_list_projects",
+ "speckle_list_models": "_tool_list_models",
+ "speckle_list_versions": "_tool_list_versions",
+ "speckle_get_version_metadata": "_tool_get_version_metadata",
+ "speckle_checkout_version": "_tool_get_version_metadata",
+ "speckle_create_model": "_tool_create_model",
+ "speckle_create_branch": "_tool_create_branch",
+ "speckle_publish_version": "_tool_publish_version",
+ "speckle_merge_model": "_tool_merge_model",
+ "speckle_merge_branch": "_tool_merge_model",
+ }
+
+ def _build_capabilities(self) -> List[ProviderTool]:
+ return [
+ ProviderTool(name="speckle_health", description="Check Speckle provider health.", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="speckle_auth_status", description="Get Speckle OAuth authentication status.", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="speckle_oauth_start", description="Generate a Speckle OAuth authorization URL using PKCE.", inputSchema={"type": "object", "properties": {}, "additionalProperties": False}),
+ ProviderTool(name="speckle_oauth_exchange_code", description="Exchange a Speckle OAuth authorization code.", inputSchema={"type": "object", "properties": {"code": {"type": "string"}, "state": {"type": "string"}}, "required": ["code", "state"], "additionalProperties": False}),
+ ProviderTool(name="speckle_oauth_refresh", description="Refresh the Speckle OAuth access token.", inputSchema={"type": "object", "properties": {}, "additionalProperties": False}),
+ ProviderTool(name="speckle_list_projects", description="List Speckle projects.", inputSchema={"type": "object", "properties": {"limit": {"type": "integer", "minimum": 1, "maximum": 100}}, "additionalProperties": False}),
+ ProviderTool(name="speckle_list_models", description="List Speckle models for a project. Branch aliases are included for compatibility.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "limit": {"type": "integer", "minimum": 1, "maximum": 100}}, "required": ["project_id"], "additionalProperties": False}),
+ ProviderTool(name="speckle_list_versions", description="List Speckle versions for a model or branch.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "model_id": {"type": "string"}, "branch_id": {"type": "string"}, "limit": {"type": "integer", "minimum": 1, "maximum": 100}}, "required": ["project_id"], "additionalProperties": False}),
+ ProviderTool(name="speckle_get_version_metadata", description="Read Speckle version metadata.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "version_id": {"type": "string"}}, "required": ["project_id", "version_id"], "additionalProperties": False}),
+ ProviderTool(name="speckle_checkout_version", description="Checkout Speckle version metadata.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "version_id": {"type": "string"}}, "required": ["project_id", "version_id"], "additionalProperties": False}),
+ ProviderTool(name="speckle_create_model", description="Create an isolated Speckle model.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "name": {"type": "string"}, "description": {"type": "string"}, "idempotency_key": {"type": "string"}}, "required": ["project_id", "name"], "additionalProperties": False}),
+ ProviderTool(name="speckle_create_branch", description="Create an isolated Speckle branch for compatibility with model workflows.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "name": {"type": "string"}, "description": {"type": "string"}, "idempotency_key": {"type": "string"}}, "required": ["project_id", "name"], "additionalProperties": False}),
+ ProviderTool(name="speckle_publish_version", description="Publish a Speckle version by creating a commit through GraphQL.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "model_id": {"type": "string"}, "object_id": {"type": "string"}, "message": {"type": "string"}, "source_application": {"type": "string"}, "idempotency_key": {"type": "string"}}, "required": ["project_id", "model_id", "object_id", "message"], "additionalProperties": False}),
+ ProviderTool(name="speckle_merge_model", description="Merge one Speckle model or branch into another through GraphQL.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "source_model_id": {"type": "string"}, "target_model_id": {"type": "string"}, "message": {"type": "string"}, "idempotency_key": {"type": "string"}}, "required": ["project_id", "source_model_id", "target_model_id", "message"], "additionalProperties": False}),
+ ProviderTool(name="speckle_merge_branch", description="Compatibility alias for merge_model.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "source_model_id": {"type": "string"}, "target_model_id": {"type": "string"}, "message": {"type": "string"}, "idempotency_key": {"type": "string"}}, "required": ["project_id", "source_model_id", "target_model_id", "message"], "additionalProperties": False}),
+ ]
+
+ async def _tool_health(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.check_health()
+
+ async def _tool_auth_status(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return self.oauth.authorization_state()
+
+ async def _tool_oauth_start(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ return self.oauth.build_authorization_url()
+
+ async def _tool_oauth_exchange_code(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.oauth.exchange_code(code=arguments["code"], state=arguments["state"])
+
+ async def _tool_oauth_refresh(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.oauth.refresh()
+
+ async def _tool_list_projects(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ query = """
+ query SpeckleProjects($limit:Int!) {
+ activeUser {
+ projects(limit:$limit) {
+ items { id name description }
+ }
+ }
+ }
+ """
+ payload = await self._graphql(query=query, variables={"limit": arguments.get("limit", 20)})
+ return {"projects": payload["activeUser"]["projects"]["items"]}
+
+ async def _tool_list_models(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ query = """
+ query SpeckleModels($projectId:String!,$limit:Int!) {
+ project(id:$projectId) {
+ id
+ models(limit:$limit) {
+ items { id name description }
+ }
+ }
+ }
+ """
+ payload = await self._graphql(query=query, variables={"projectId": arguments["project_id"], "limit": arguments.get("limit", 20)})
+ models = payload["project"]["models"]["items"]
+ return {
+ "project_id": arguments["project_id"],
+ "models": [
+ {
+ **model,
+ "branch_id": model["id"],
+ "branch_name": model["name"],
+ }
+ for model in models
+ ],
+ }
+
+ async def _tool_list_versions(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ model_id = arguments.get("model_id") or arguments.get("branch_id")
+ if not model_id:
+ raise ValueError("model_id or branch_id is required")
+ query = """
+ query SpeckleVersions($projectId:String!,$modelId:String!,$limit:Int!) {
+ project(id:$projectId) {
+ model(id:$modelId) {
+ id
+ versions(limit:$limit) {
+ items { id message createdAt referencedObject }
+ }
+ }
+ }
+ }
+ """
+ payload = await self._graphql(query=query, variables={"projectId": arguments["project_id"], "modelId": model_id, "limit": arguments.get("limit", 20)})
+ return {"project_id": arguments["project_id"], "model_id": model_id, "versions": payload["project"]["model"]["versions"]["items"]}
+
+ async def _tool_get_version_metadata(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ query = """
+ query SpeckleVersion($projectId:String!,$versionId:String!) {
+ project(id:$projectId) {
+ version(id:$versionId) {
+ id
+ message
+ createdAt
+ sourceApplication
+ referencedObject
+ }
+ }
+ }
+ """
+ payload = await self._graphql(query=query, variables={"projectId": arguments["project_id"], "versionId": arguments["version_id"]})
+ return {"project_id": arguments["project_id"], "version": payload["project"]["version"]}
+
+ async def _tool_create_model(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ mutation = """
+ mutation SpeckleCreateModel($input:CreateModelInput!) {
+ projectMutations {
+ modelCreate(input:$input) { id name description }
+ }
+ }
+ """
+ variables = {
+ "input": {
+ "projectId": arguments["project_id"],
+ "name": arguments["name"],
+ "description": arguments.get("description"),
+ }
+ }
+ payload = await self._graphql(
+ query=mutation,
+ variables=variables,
+ idempotency_key=arguments.get("idempotency_key"),
+ )
+ return {"model": payload["projectMutations"]["modelCreate"]}
+
+ async def _tool_create_branch(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ return await self._tool_create_model(arguments)
+
+ async def _tool_publish_version(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ mutation = """
+ mutation SpecklePublishVersion($input:CreateVersionInput!) {
+ projectMutations {
+ versionCreate(input:$input) { id message referencedObject }
+ }
+ }
+ """
+ variables = {
+ "input": {
+ "projectId": arguments["project_id"],
+ "modelId": arguments["model_id"],
+ "objectId": arguments["object_id"],
+ "message": arguments["message"],
+ "sourceApplication": arguments.get("source_application", "Autodesk-Revit-MCP-Server"),
+ }
+ }
+ payload = await self._graphql(
+ query=mutation,
+ variables=variables,
+ idempotency_key=arguments.get("idempotency_key"),
+ )
+ return {"version": payload["projectMutations"]["versionCreate"]}
+
+ async def _tool_merge_model(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ if self._merge_operation_builder is None:
+ raise NotImplementedError(
+ "Speckle merge is unsupported until an explicit merge_operation_builder is configured"
+ )
+ operation = self._merge_operation_builder(arguments)
+ query = operation["query"]
+ variables = operation["variables"]
+ payload = await self._graphql(
+ query=query,
+ variables=variables,
+ idempotency_key=arguments.get("idempotency_key"),
+ )
+ result_path = operation.get("result_path")
+ merged = payload
+ if result_path:
+ for segment in result_path:
+ merged = merged[segment]
+ success_value = operation.get("success_value", True)
+ if success_value is not None:
+ merged = merged == success_value
+ if not merged:
+ raise RuntimeError("Speckle merge did not succeed")
+ return {"merged": True}
+
+ async def _graphql(
+ self,
+ *,
+ query: str,
+ variables: Dict[str, Any],
+ idempotency_key: str | None = None,
+ ) -> Dict[str, Any]:
+ body = {"query": query, "variables": variables}
+ headers = _json_headers(idempotency_key)
+ payload = await self._post_json(self.graphql_url, json_body=body, headers=headers)
+ if payload.get("errors"):
+ raise RuntimeError(f"Speckle GraphQL error: {json.dumps(_sanitize(payload['errors']))}")
+ return payload["data"]
+
+
+class AutodeskDataProvider(CloudProviderBase):
+ provider_identity = "autodesk_data"
+
+ def __init__(
+ self,
+ *,
+ auth_base_url: str = "https://developer.api.autodesk.com/authentication/v2",
+ api_base_url: str = "https://developer.api.autodesk.com",
+ issues_endpoint: str | None = None,
+ client_id: str | None = None,
+ client_secret: str | None = None,
+ redirect_uri: str = "https://localhost/callback",
+ scopes: List[str] | None = None,
+ credential_callback: CredentialCallback | None = None,
+ http_client: httpx.AsyncClient | None = None,
+ oauth_http_client: httpx.AsyncClient | None = None,
+ transport: httpx.AsyncBaseTransport | None = None,
+ oauth_transport: httpx.AsyncBaseTransport | None = None,
+ allow_localhost_http: bool = False,
+ oauth_pending_state_ttl_seconds: int = 600,
+ oauth_max_pending_states: int = 32,
+ ) -> None:
+ _validate_https_url(auth_base_url, allow_localhost_http=allow_localhost_http, label="auth_base_url")
+ _validate_https_url(api_base_url, allow_localhost_http=allow_localhost_http, label="api_base_url")
+ self.auth_base_url = auth_base_url.rstrip("/")
+ self.api_base_url = api_base_url.rstrip("/")
+ self.issues_endpoint = issues_endpoint
+ if issues_endpoint:
+ _validate_https_url(issues_endpoint, allow_localhost_http=allow_localhost_http, label="issues_endpoint")
+ oauth = OAuth2PKCETransport(
+ provider_name="aps",
+ client_id=client_id or os.getenv("APS_CLIENT_ID") or os.getenv("AUTODESK_CLIENT_ID"),
+ client_secret=client_secret or os.getenv("APS_CLIENT_SECRET") or os.getenv("AUTODESK_CLIENT_SECRET"),
+ redirect_uri=redirect_uri,
+ auth_url=f"{self.auth_base_url}/authorize",
+ token_url=f"{self.auth_base_url}/token",
+ scopes=scopes or ["data:read", "data:write"],
+ env_prefix="APS",
+ credential_callback=credential_callback,
+ http_client=oauth_http_client,
+ transport=oauth_transport,
+ allow_localhost_http=allow_localhost_http,
+ pending_state_ttl_seconds=oauth_pending_state_ttl_seconds,
+ max_pending_states=oauth_max_pending_states,
+ )
+ super().__init__(oauth=oauth, http_client=http_client, transport=transport)
+
+ def _tool_dispatch(self) -> Dict[str, str]:
+ return {
+ "autodesk_data_health": "_tool_health",
+ "autodesk_data_auth_status": "_tool_auth_status",
+ "autodesk_data_oauth_start": "_tool_oauth_start",
+ "autodesk_data_oauth_exchange_code": "_tool_oauth_exchange_code",
+ "autodesk_data_oauth_refresh": "_tool_oauth_refresh",
+ "autodesk_data_list_hubs": "_tool_list_hubs",
+ "autodesk_data_list_projects": "_tool_list_projects",
+ "autodesk_data_list_items": "_tool_list_items",
+ "autodesk_data_get_version_metadata": "_tool_get_version_metadata",
+ "autodesk_data_checkout_version": "_tool_get_version_metadata",
+ "autodesk_data_create_topic": "_tool_create_topic",
+ "autodesk_data_create_issue": "_tool_create_topic",
+ }
+
+ def _build_capabilities(self) -> List[ProviderTool]:
+ return [
+ ProviderTool(name="autodesk_data_health", description="Check Autodesk Data provider health.", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="autodesk_data_auth_status", description="Get Autodesk OAuth authentication status.", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="autodesk_data_oauth_start", description="Generate an Autodesk OAuth authorization URL using PKCE.", inputSchema={"type": "object", "properties": {}, "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_oauth_exchange_code", description="Exchange an Autodesk OAuth authorization code.", inputSchema={"type": "object", "properties": {"code": {"type": "string"}, "state": {"type": "string"}}, "required": ["code", "state"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_oauth_refresh", description="Refresh the Autodesk OAuth access token.", inputSchema={"type": "object", "properties": {}, "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_list_hubs", description="List Autodesk Construction Cloud hubs.", inputSchema={"type": "object", "properties": {}, "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_list_projects", description="List Autodesk projects in a hub.", inputSchema={"type": "object", "properties": {"hub_id": {"type": "string"}}, "required": ["hub_id"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_list_items", description="List Autodesk items in a project folder or container.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "folder_id": {"type": "string"}}, "required": ["project_id", "folder_id"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_get_version_metadata", description="Read Autodesk item/version metadata.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "version_id": {"type": "string"}}, "required": ["project_id", "version_id"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_checkout_version", description="Checkout Autodesk version metadata.", inputSchema={"type": "object", "properties": {"project_id": {"type": "string"}, "version_id": {"type": "string"}}, "required": ["project_id", "version_id"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_create_topic", description="Create a BCF-compatible issue/topic through a configured endpoint.", inputSchema={"type": "object", "properties": {"container_id": {"type": "string"}, "title": {"type": "string"}, "description": {"type": "string"}, "status": {"type": "string"}, "type": {"type": "string"}, "ifc_guid_refs": {"type": "array", "items": {"type": "string"}}, "viewpoint": {"type": "object"}, "idempotency_key": {"type": "string"}}, "required": ["container_id", "title", "description"], "additionalProperties": False}),
+ ProviderTool(name="autodesk_data_create_issue", description="Compatibility alias for create_topic.", inputSchema={"type": "object", "properties": {"container_id": {"type": "string"}, "title": {"type": "string"}, "description": {"type": "string"}, "status": {"type": "string"}, "type": {"type": "string"}, "ifc_guid_refs": {"type": "array", "items": {"type": "string"}}, "viewpoint": {"type": "object"}, "idempotency_key": {"type": "string"}}, "required": ["container_id", "title", "description"], "additionalProperties": False}),
+ ]
+
+ async def _tool_health(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.check_health()
+
+ async def _tool_auth_status(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return self.oauth.authorization_state()
+
+ async def _tool_oauth_start(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ return self.oauth.build_authorization_url()
+
+ async def _tool_oauth_exchange_code(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.oauth.exchange_code(code=arguments["code"], state=arguments["state"])
+
+ async def _tool_oauth_refresh(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ return await self.oauth.refresh()
+
+ async def _tool_list_hubs(self, _: Dict[str, Any]) -> Dict[str, Any]:
+ payload = await self._get_json(self._hub_list_url())
+ return {"hubs": payload.get("data", [])}
+
+ async def _tool_list_projects(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ payload = await self._get_json(self._projects_url(arguments["hub_id"]))
+ return {"hub_id": arguments["hub_id"], "projects": payload.get("data", [])}
+
+ async def _tool_list_items(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ payload = await self._get_json(self._folder_contents_url(arguments["project_id"], arguments["folder_id"]))
+ return {"project_id": arguments["project_id"], "folder_id": arguments["folder_id"], "items": payload.get("data", [])}
+
+ async def _tool_get_version_metadata(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ payload = await self._get_json(self._version_url(arguments["project_id"], arguments["version_id"]))
+ return {"project_id": arguments["project_id"], "version": payload.get("data")}
+
+ async def _tool_create_topic(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ if not self.issues_endpoint:
+ raise ValueError("issues_endpoint is not configured")
+ payload = BCFTopicPayload.model_validate(
+ {
+ "title": arguments["title"],
+ "description": arguments["description"],
+ "status": arguments.get("status"),
+ "type": arguments.get("type"),
+ "ifc_guid_refs": arguments.get("ifc_guid_refs", []),
+ "viewpoint": arguments.get("viewpoint"),
+ }
+ )
+ body = {
+ "containerId": arguments["container_id"],
+ "topic": {
+ "title": payload.title,
+ "description": payload.description,
+ "status": payload.status,
+ "type": payload.topic_type,
+ "ifcGuidRefs": payload.ifc_guid_refs,
+ "viewpoint": payload.viewpoint.model_dump(exclude_none=True) if payload.viewpoint else None,
+ },
+ }
+ return await self._post_json(
+ self.issues_endpoint,
+ json_body=body,
+ headers=_json_headers(arguments.get("idempotency_key")),
+ )
+
+ def _hub_list_url(self) -> str:
+ return f"{self.api_base_url}/project/v1/hubs"
+
+ def _projects_url(self, hub_id: str) -> str:
+ return f"{self.api_base_url}/project/v1/hubs/{self._path_segment(hub_id, 'hub_id')}/projects"
+
+ def _folder_contents_url(self, project_id: str, folder_id: str) -> str:
+ return (
+ f"{self.api_base_url}/data/v1/projects/{self._path_segment(project_id, 'project_id')}"
+ f"/folders/{self._path_segment(folder_id, 'folder_id')}/contents"
+ )
+
+ def _version_url(self, project_id: str, version_id: str) -> str:
+ return (
+ f"{self.api_base_url}/data/v1/projects/{self._path_segment(project_id, 'project_id')}"
+ f"/versions/{self._path_segment(version_id, 'version_id')}"
+ )
+
+ @staticmethod
+ def _path_segment(identifier: str, label: str) -> str:
+ value = str(identifier).strip()
+ if not value:
+ raise ValueError(f"{label} is required")
+ return quote(value, safe="")
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/fake.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/fake.py
new file mode 100644
index 0000000..71e72e3
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/fake.py
@@ -0,0 +1,32 @@
+from typing import Dict, Any, List
+from .base import AECProvider, ProviderTool
+
+class FakeProvider(AECProvider):
+ def get_identity(self) -> str:
+ return "fake"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return [
+ ProviderTool(
+ name="fake_tool",
+ description="A fake tool for testing",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "input_val": {"type": "string"}
+ },
+ "required": ["input_val"]
+ }
+ )
+ ]
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {"status": "OK", "provider": "fake"}
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ if name == "fake_tool":
+ return {"result": f"processed {arguments.get('input_val')}"}
+ raise ValueError(f"Unknown fake tool: {name}")
+
+ async def shutdown(self) -> None:
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py
new file mode 100644
index 0000000..8a258cd
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/graph.py
@@ -0,0 +1,802 @@
+from __future__ import annotations
+
+from itertools import combinations
+from math import isfinite
+from typing import Any, Dict, List, Optional, Sequence
+
+import networkx as nx
+
+from .base import AECProvider, ProviderTool
+
+
+RELATION_TYPES = {
+ "CONTAINED_IN",
+ "SUPPORTED_BY",
+ "CONNECTED_TO",
+ "ADJACENT_TO",
+ "HAS_MATERIAL",
+}
+
+DEFAULT_LIMIT = 100
+MAX_LIMIT = 500
+
+
+class SemanticGraphProvider(AECProvider):
+ def __init__(self) -> None:
+ self._graph = nx.MultiDiGraph()
+ self._init_capabilities()
+
+ def get_identity(self) -> str:
+ return "graph"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {
+ "status": "healthy",
+ "provider": "graph",
+ "nodes": self._graph.number_of_nodes(),
+ "edges": self._graph.number_of_edges(),
+ "relation_counts": self._relation_counts(),
+ }
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ tool_name = name.replace(".", "_")
+ if tool_name == "graph_health":
+ return await self.check_health()
+ if tool_name == "graph_compile":
+ return self._compile(arguments)
+ if tool_name == "graph_add_relation":
+ return self._add_relation(arguments)
+ if tool_name == "graph_query_relations":
+ return self._query_relations(arguments)
+ if tool_name == "graph_audit_clashes":
+ return self._audit_clashes(arguments)
+ if tool_name == "graph_audit_disconnected":
+ return self._audit_disconnected(arguments)
+ if tool_name == "graph_audit_structural_loads":
+ return self._audit_structural_loads(arguments)
+ raise ValueError(f"Unknown graph tool '{name}'")
+
+ def _init_capabilities(self) -> None:
+ self._capabilities = [
+ ProviderTool(
+ name="graph_health",
+ description="Check graph provider health and current graph size.",
+ inputSchema={"type": "object", "properties": {}, "required": []},
+ ),
+ ProviderTool(
+ name="graph_compile",
+ description="Compile workspace model nodes and relations into the in-memory semantic graph.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "nodes": {
+ "type": "array",
+ "items": {"type": "object"},
+ "description": "Generic node payloads with id, type, attributes, and optional aabb data.",
+ },
+ "edges": {
+ "type": "array",
+ "items": {"type": "object"},
+ "description": "Generic edge payloads with source, target, relation, and optional attributes.",
+ },
+ "allow_dangling_edges": {
+ "type": "boolean",
+ "default": False,
+ "description": "If true, create placeholder nodes for edge endpoints that are missing from the payload.",
+ },
+ "replace": {
+ "type": "boolean",
+ "default": True,
+ "description": "If true, replace the existing graph atomically. If false, merge into a copied graph.",
+ },
+ },
+ "required": ["nodes", "edges"],
+ },
+ ),
+ ProviderTool(
+ name="graph_add_relation",
+ description="Add a typed relation between two existing nodes.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "source_id": {"type": "string"},
+ "target_id": {"type": "string"},
+ "relation": {
+ "type": "string",
+ "enum": sorted(RELATION_TYPES),
+ },
+ "attributes": {"type": "object"},
+ },
+ "required": ["source_id", "target_id", "relation"],
+ },
+ ),
+ ProviderTool(
+ name="graph_query_relations",
+ description="Query relations by node, related node, relation type, and direction.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "node_id": {"type": "string"},
+ "related_node_id": {"type": "string"},
+ "relation": {
+ "type": "string",
+ "enum": sorted(RELATION_TYPES),
+ },
+ "direction": {
+ "type": "string",
+ "enum": ["outgoing", "incoming", "both"],
+ "default": "both",
+ },
+ "limit": {
+ "type": "integer",
+ "default": DEFAULT_LIMIT,
+ },
+ },
+ "required": [],
+ },
+ ),
+ ProviderTool(
+ name="graph_audit_clashes",
+ description="Audit axis-aligned bounding boxes for clashes using a tolerance value.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "nodes": {
+ "type": "array",
+ "items": {"type": "object"},
+ "description": "Optional node payloads with id and aabb data. If omitted, use graph nodes with stored aabb attributes.",
+ },
+ "node_ids": {
+ "type": "array",
+ "items": {"type": "string"},
+ },
+ "tolerance": {
+ "type": "number",
+ "default": 0.0,
+ },
+ "limit": {
+ "type": "integer",
+ "default": DEFAULT_LIMIT,
+ },
+ },
+ "required": [],
+ },
+ ),
+ ProviderTool(
+ name="graph_audit_disconnected",
+ description="Audit disconnected nodes or components using degree and connectivity rules.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "node_ids": {
+ "type": "array",
+ "items": {"type": "string"},
+ },
+ "node_types": {
+ "type": "array",
+ "items": {"type": "string"},
+ },
+ "relation_types": {
+ "type": "array",
+ "items": {
+ "type": "string",
+ "enum": sorted(RELATION_TYPES),
+ },
+ },
+ "min_degree": {
+ "type": "integer",
+ "default": 1,
+ },
+ "limit": {
+ "type": "integer",
+ "default": DEFAULT_LIMIT,
+ },
+ },
+ "required": [],
+ },
+ ),
+ ProviderTool(
+ name="graph_audit_structural_loads",
+ description="Audit structural load-bearing and support consistency using SUPPORTED_BY relations.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "node_ids": {
+ "type": "array",
+ "items": {"type": "string"},
+ },
+ "node_types": {
+ "type": "array",
+ "items": {"type": "string"},
+ },
+ "limit": {
+ "type": "integer",
+ "default": DEFAULT_LIMIT,
+ },
+ },
+ "required": [],
+ },
+ ),
+ ]
+
+ def _compile(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ raw_nodes = arguments.get("nodes", [])
+ raw_edges = arguments.get("edges", [])
+ if not isinstance(raw_nodes, list):
+ raise ValueError("Argument 'nodes' must be a list.")
+ if not isinstance(raw_edges, list):
+ raise ValueError("Argument 'edges' must be a list.")
+ allow_dangling_edges = bool(arguments.get("allow_dangling_edges", False))
+ replace = bool(arguments.get("replace", True))
+
+ node_records = [self._normalize_node_payload(node) for node in raw_nodes]
+ edge_records = [self._normalize_edge_payload(edge) for edge in raw_edges]
+
+ seen_node_ids: set[str] = set()
+ for node in node_records:
+ if node["id"] in seen_node_ids:
+ raise ValueError(f"Duplicate node id '{node['id']}' in compile payload.")
+ seen_node_ids.add(node["id"])
+
+ base_node_ids = set(self._graph.nodes) if not replace else set()
+ missing_edge_nodes = []
+ for edge in edge_records:
+ for endpoint in (edge["source_id"], edge["target_id"]):
+ if endpoint not in seen_node_ids and endpoint not in base_node_ids:
+ missing_edge_nodes.append(endpoint)
+
+ if missing_edge_nodes and not allow_dangling_edges:
+ unique_missing = sorted(set(missing_edge_nodes))
+ raise ValueError(
+ "Dangling edges reference missing node ids: " + ", ".join(unique_missing)
+ )
+
+ staged = nx.MultiDiGraph() if replace else self._graph.copy(as_view=False)
+
+ for node in node_records:
+ staged.add_node(node["id"], **node["attributes"])
+
+ for edge in edge_records:
+ if allow_dangling_edges:
+ for endpoint in (edge["source_id"], edge["target_id"]):
+ if endpoint not in staged:
+ staged.add_node(endpoint, placeholder=True)
+ else:
+ if edge["source_id"] not in staged or edge["target_id"] not in staged:
+ raise ValueError(
+ f"Dangling edge '{edge['relation']}' references missing node(s)."
+ )
+ staged.add_edge(
+ edge["source_id"],
+ edge["target_id"],
+ relation=edge["relation"],
+ **edge["attributes"],
+ )
+
+ self._graph = staged
+ return {
+ "status": "success",
+ "compiled": {
+ "nodes_received": len(node_records),
+ "edges_received": len(edge_records),
+ "nodes_total": self._graph.number_of_nodes(),
+ "edges_total": self._graph.number_of_edges(),
+ },
+ }
+
+ def _add_relation(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ source_id = self._normalize_node_id(
+ arguments.get("source_id", arguments.get("source"))
+ )
+ target_id = self._normalize_node_id(
+ arguments.get("target_id", arguments.get("target"))
+ )
+ relation = self._normalize_relation(
+ arguments.get("relation", arguments.get("relation_type", arguments.get("type")))
+ )
+ attributes = arguments.get("attributes", {})
+ if not isinstance(attributes, dict):
+ raise ValueError("Relation attributes must be an object if provided.")
+ attributes = self._normalize_json_safe(attributes)
+
+ self._require_node(source_id)
+ self._require_node(target_id)
+
+ edge_key = self._graph.add_edge(source_id, target_id, relation=relation, **attributes)
+ return {
+ "status": "success",
+ "relation": {
+ "source_id": source_id,
+ "target_id": target_id,
+ "relation": relation,
+ "edge_key": edge_key,
+ "attributes": self._normalize_json_safe(attributes),
+ },
+ }
+
+ def _query_relations(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ node_id = self._normalize_optional_node_id(arguments.get("node_id"))
+ related_node_id = self._normalize_optional_node_id(arguments.get("related_node_id"))
+ relation = self._normalize_optional_relation(arguments.get("relation"))
+ direction = arguments.get("direction", "both")
+ limit = self._bounded_limit(arguments.get("limit", DEFAULT_LIMIT))
+
+ if direction not in {"outgoing", "incoming", "both"}:
+ raise ValueError("Direction must be one of: outgoing, incoming, both.")
+ if "node_id" in arguments and not isinstance(arguments.get("node_id"), (str, int, type(None))):
+ raise ValueError("Argument 'node_id' must be a string or integer if provided.")
+ if "related_node_id" in arguments and not isinstance(arguments.get("related_node_id"), (str, int, type(None))):
+ raise ValueError("Argument 'related_node_id' must be a string or integer if provided.")
+ if node_id is not None:
+ self._require_node(node_id)
+ if related_node_id is not None:
+ self._require_node(related_node_id)
+
+ edges = []
+ for source_id, target_id, edge_key, data in self._graph.edges(keys=True, data=True):
+ rel = self._normalize_relation(data.get("relation", ""))
+ if relation is not None and rel != relation:
+ continue
+
+ if direction == "outgoing" and node_id is not None and source_id != node_id:
+ continue
+ if direction == "incoming" and node_id is not None and target_id != node_id:
+ continue
+ if direction == "both" and node_id is not None and node_id not in {source_id, target_id}:
+ continue
+
+ if related_node_id is not None and related_node_id not in {source_id, target_id}:
+ continue
+
+ edges.append(
+ {
+ "source_id": source_id,
+ "target_id": target_id,
+ "relation": rel,
+ "edge_key": edge_key,
+ "attributes": self._normalize_json_safe(
+ {k: v for k, v in data.items() if k != "relation"}
+ ),
+ }
+ )
+
+ edges = self._sort_relation_records(edges)
+ total = len(edges)
+ return {
+ "status": "success",
+ "relations": edges[:limit],
+ "count": min(total, limit),
+ "total": total,
+ "truncated": total > limit,
+ }
+
+ def _audit_clashes(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ tolerance = self._normalize_number(arguments.get("tolerance", 0.0))
+ limit = self._bounded_limit(arguments.get("limit", DEFAULT_LIMIT))
+ raw_nodes = arguments.get("nodes")
+ node_ids = arguments.get("node_ids")
+ if raw_nodes is not None and not isinstance(raw_nodes, list):
+ raise ValueError("Argument 'nodes' must be a list when provided.")
+ if node_ids is not None and not isinstance(node_ids, list):
+ raise ValueError("Argument 'node_ids' must be a list when provided.")
+
+ records = self._collect_aabb_records(raw_nodes, node_ids)
+ clashes = []
+ for first, second in combinations(records, 2):
+ if self._aabbs_clash(first["aabb"], second["aabb"], tolerance):
+ clashes.append(
+ {
+ "node_a": first["id"],
+ "node_b": second["id"],
+ "aabb_a": first["aabb"],
+ "aabb_b": second["aabb"],
+ }
+ )
+
+ clashes = sorted(clashes, key=lambda item: (item["node_a"], item["node_b"]))
+ total = len(clashes)
+ return {
+ "status": "success",
+ "tolerance": tolerance,
+ "clashes": clashes[:limit],
+ "count": min(total, limit),
+ "total": total,
+ "truncated": total > limit,
+ }
+
+ def _audit_disconnected(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ limit = self._bounded_limit(arguments.get("limit", DEFAULT_LIMIT))
+ min_degree = self._normalize_int(arguments.get("min_degree", 1), minimum=0)
+ node_ids = self._normalize_optional_node_id_list(arguments.get("node_ids"))
+ node_types = self._normalize_string_list(arguments.get("node_types"))
+ relation_types = self._normalize_relation_list(arguments.get("relation_types"))
+
+ selected_nodes = self._select_nodes(node_ids=node_ids, node_types=node_types)
+ if not selected_nodes:
+ return {
+ "status": "success",
+ "selected_nodes": 0,
+ "disconnected_nodes": [],
+ "components": [],
+ "count": 0,
+ "total": 0,
+ "truncated": False,
+ }
+
+ filtered = nx.Graph()
+ filtered.add_nodes_from(selected_nodes)
+
+ for source_id, target_id, data in self._graph.edges(data=True):
+ rel = self._normalize_relation(data.get("relation", ""))
+ if relation_types is not None and rel not in relation_types:
+ continue
+ if source_id not in selected_nodes or target_id not in selected_nodes:
+ continue
+ filtered.add_edge(source_id, target_id, relation=rel)
+
+ disconnected_nodes = sorted(
+ node_id
+ for node_id in filtered.nodes
+ if filtered.degree(node_id) < min_degree
+ )
+ components = [
+ sorted(component)
+ for component in nx.connected_components(filtered)
+ ]
+ components.sort(key=lambda component: (len(component), component))
+
+ return {
+ "status": "success",
+ "selected_nodes": len(selected_nodes),
+ "min_degree": min_degree,
+ "relation_types": sorted(relation_types) if relation_types is not None else sorted(RELATION_TYPES),
+ "disconnected_nodes": disconnected_nodes[:limit],
+ "components": components[:limit],
+ "count": min(len(disconnected_nodes), limit),
+ "total": len(disconnected_nodes),
+ "truncated": len(disconnected_nodes) > limit,
+ }
+
+ def _audit_structural_loads(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ limit = self._bounded_limit(arguments.get("limit", DEFAULT_LIMIT))
+ node_ids = self._normalize_optional_node_id_list(arguments.get("node_ids"))
+ node_types = self._normalize_string_list(arguments.get("node_types"))
+ selected_nodes = self._select_nodes(node_ids=node_ids, node_types=node_types)
+ node_issues = []
+ edge_issues = []
+
+ supported_by_edges = [
+ (source_id, target_id, data)
+ for source_id, target_id, data in self._graph.edges(data=True)
+ if self._normalize_relation(data.get("relation", "")) == "SUPPORTED_BY"
+ ]
+
+ outgoing_supported_by: Dict[str, List[str]] = {}
+ for source_id, target_id, _data in supported_by_edges:
+ outgoing_supported_by.setdefault(source_id, []).append(target_id)
+
+ for node_id in sorted(selected_nodes):
+ attrs = self._normalize_json_safe(dict(self._graph.nodes[node_id]))
+ requires_support = bool(attrs.get("requires_support", False))
+ load_bearing = attrs.get("load_bearing")
+ is_support = bool(attrs.get("is_support", False))
+
+ supports = sorted(set(outgoing_supported_by.get(node_id, [])))
+ if requires_support and not supports:
+ node_issues.append(
+ {
+ "node_id": node_id,
+ "issue": "missing_support",
+ "message": "Node is marked as requiring support but has no SUPPORTED_BY relation.",
+ }
+ )
+ if load_bearing is False and supports:
+ node_issues.append(
+ {
+ "node_id": node_id,
+ "issue": "support_target_not_load_bearing",
+ "message": "Node has outgoing SUPPORTED_BY relations but is marked as not load-bearing.",
+ }
+ )
+ if is_support and load_bearing is False:
+ node_issues.append(
+ {
+ "node_id": node_id,
+ "issue": "support_flag_conflict",
+ "message": "Node is marked as a support but explicitly not load-bearing.",
+ }
+ )
+
+ for source_id, target_id, _data in supported_by_edges:
+ if source_id not in selected_nodes or target_id not in selected_nodes:
+ continue
+ target_attrs = self._normalize_json_safe(dict(self._graph.nodes[target_id]))
+ if target_attrs.get("load_bearing") is False:
+ edge_issues.append(
+ {
+ "source_id": source_id,
+ "target_id": target_id,
+ "issue": "unsupported_support_target",
+ "message": "SUPPORTED_BY edge targets a node marked as not load-bearing.",
+ }
+ )
+ elif not target_attrs.get("load_bearing", False) and not target_attrs.get("is_support", False):
+ edge_issues.append(
+ {
+ "source_id": source_id,
+ "target_id": target_id,
+ "issue": "missing_supporting_role",
+ "message": "SUPPORTED_BY edge targets a node without load-bearing or support attributes.",
+ }
+ )
+
+ node_issues = self._sort_issue_records(node_issues)
+ edge_issues = self._sort_issue_records(edge_issues)
+ total = len(node_issues) + len(edge_issues)
+ issues = (node_issues + edge_issues)[:limit]
+ return {
+ "status": "success",
+ "selected_nodes": len(selected_nodes),
+ "issues": issues,
+ "node_issues": node_issues[:limit],
+ "edge_issues": edge_issues[:limit],
+ "count": min(total, limit),
+ "total": total,
+ "truncated": total > limit,
+ }
+
+ def _collect_aabb_records(
+ self,
+ raw_nodes: Optional[Sequence[Dict[str, Any]]],
+ node_ids: Optional[Sequence[Any]],
+ ) -> List[Dict[str, Any]]:
+ records: List[Dict[str, Any]] = []
+ if raw_nodes is not None:
+ for raw_node in raw_nodes:
+ if not isinstance(raw_node, dict):
+ raise ValueError("Each node must be an object.")
+ node_id = self._normalize_node_id(raw_node["id"])
+ aabb = self._parse_aabb(raw_node.get("aabb"))
+ records.append({"id": node_id, "aabb": aabb})
+ return sorted(records, key=lambda item: item["id"])
+
+ selected_ids = self._normalize_optional_node_id_list(node_ids)
+ if selected_ids is None:
+ selected_ids = sorted(self._graph.nodes)
+ for node_id in selected_ids:
+ self._require_node(node_id)
+ aabb = self._parse_aabb(self._graph.nodes[node_id].get("aabb"))
+ records.append({"id": node_id, "aabb": aabb})
+ return sorted(records, key=lambda item: item["id"])
+
+ def _select_nodes(
+ self,
+ node_ids: Optional[List[str]] = None,
+ node_types: Optional[List[str]] = None,
+ ) -> List[str]:
+ selected = []
+ allowed_ids = set(node_ids) if node_ids is not None else None
+ allowed_types = set(node_types) if node_types is not None else None
+ for node_id, attrs in self._graph.nodes(data=True):
+ if allowed_ids is not None and node_id not in allowed_ids:
+ continue
+ if allowed_types is not None and attrs.get("type") not in allowed_types:
+ continue
+ selected.append(node_id)
+ return sorted(selected)
+
+ def _require_node(self, node_id: str) -> None:
+ if node_id not in self._graph:
+ raise ValueError(f"Unknown node id '{node_id}'.")
+
+ def _normalize_node_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+ if not isinstance(payload, dict):
+ raise ValueError("Each node must be an object.")
+ node_id = self._normalize_node_id(
+ payload.get("id", payload.get("node_id", payload.get("element_id")))
+ )
+ attrs = {
+ key: self._normalize_json_safe(value)
+ for key, value in payload.items()
+ if key not in {"id", "attributes"}
+ }
+ node_attrs = self._normalize_json_safe(payload.get("attributes", {}))
+ if not isinstance(node_attrs, dict):
+ raise ValueError("Node 'attributes' must be an object if provided.")
+ attrs.update(node_attrs)
+ if "aabb" in payload:
+ attrs["aabb"] = self._parse_aabb(payload.get("aabb"))
+ if "type" in payload:
+ attrs["type"] = self._normalize_json_safe(payload["type"])
+ return {"id": node_id, "attributes": attrs}
+
+ def _normalize_edge_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+ if not isinstance(payload, dict):
+ raise ValueError("Each edge must be an object.")
+ source_id = self._normalize_node_id(
+ payload.get("source_id", payload.get("source", payload.get("from")))
+ )
+ target_id = self._normalize_node_id(
+ payload.get("target_id", payload.get("target", payload.get("to")))
+ )
+ relation = self._normalize_relation(
+ payload.get("relation", payload.get("relation_type", payload.get("type")))
+ )
+ attrs = {
+ key: self._normalize_json_safe(value)
+ for key, value in payload.items()
+ if key not in {"source_id", "source", "target_id", "target", "relation", "type", "attributes"}
+ }
+ edge_attrs = self._normalize_json_safe(payload.get("attributes", {}))
+ if not isinstance(edge_attrs, dict):
+ raise ValueError("Edge 'attributes' must be an object if provided.")
+ attrs.update(edge_attrs)
+ return {
+ "source_id": source_id,
+ "target_id": target_id,
+ "relation": relation,
+ "attributes": attrs,
+ }
+
+ def _normalize_node_id(self, value: Any) -> str:
+ if isinstance(value, bool) or value is None:
+ raise ValueError("Node ids must be non-empty strings or integers.")
+ if isinstance(value, int):
+ text = str(value)
+ elif isinstance(value, str):
+ text = value.strip()
+ else:
+ raise ValueError("Node ids must be non-empty strings or integers.")
+ if not text:
+ raise ValueError("Node ids must be non-empty strings or integers.")
+ return text
+
+ def _normalize_optional_node_id(self, value: Any) -> Optional[str]:
+ if value is None:
+ return None
+ return self._normalize_node_id(value)
+
+ def _normalize_optional_node_id_list(self, values: Any) -> Optional[List[str]]:
+ if values is None:
+ return None
+ if not isinstance(values, list):
+ raise ValueError("Node id lists must be lists.")
+ return [self._normalize_node_id(value) for value in values]
+
+ def _normalize_relation(self, value: Any) -> str:
+ if not isinstance(value, str) or not value.strip():
+ raise ValueError("Relation type must be a non-empty string.")
+ relation = value.strip().upper()
+ if relation not in RELATION_TYPES:
+ raise ValueError(
+ f"Unsupported relation type '{value}'. Allowed types: {', '.join(sorted(RELATION_TYPES))}."
+ )
+ return relation
+
+ def _normalize_optional_relation(self, value: Any) -> Optional[str]:
+ if value is None:
+ return None
+ return self._normalize_relation(value)
+
+ def _normalize_relation_list(self, values: Any) -> Optional[List[str]]:
+ if values is None:
+ return None
+ if not isinstance(values, list):
+ raise ValueError("Relation type lists must be lists.")
+ return [self._normalize_relation(value) for value in values]
+
+ def _normalize_string_list(self, values: Any) -> Optional[List[str]]:
+ if values is None:
+ return None
+ if not isinstance(values, list):
+ raise ValueError("String lists must be lists.")
+ normalized = []
+ for value in values:
+ if not isinstance(value, str) or not value.strip():
+ raise ValueError("String list values must be non-empty strings.")
+ normalized.append(value.strip())
+ return normalized
+
+ def _normalize_int(self, value: Any, minimum: int = 0) -> int:
+ if isinstance(value, bool) or not isinstance(value, int):
+ raise ValueError("Expected an integer value.")
+ if value < minimum:
+ raise ValueError(f"Integer value must be >= {minimum}.")
+ return value
+
+ def _bounded_limit(self, value: Any) -> int:
+ limit = self._normalize_int(value, minimum=1)
+ return min(limit, MAX_LIMIT)
+
+ def _normalize_number(self, value: Any) -> float:
+ if isinstance(value, bool) or not isinstance(value, (int, float)):
+ raise ValueError("Expected a numeric value.")
+ numeric = float(value)
+ if not isfinite(numeric):
+ raise ValueError("Numeric value must be finite.")
+ return numeric
+
+ def _normalize_json_safe(self, value: Any) -> Any:
+ if value is None or isinstance(value, (str, int, float, bool)):
+ if isinstance(value, float) and not isfinite(value):
+ return str(value)
+ return value
+ if isinstance(value, dict):
+ return {
+ str(key): self._normalize_json_safe(val)
+ for key, val in sorted(value.items(), key=lambda item: str(item[0]))
+ }
+ if isinstance(value, (list, tuple)):
+ return [self._normalize_json_safe(item) for item in value]
+ if isinstance(value, set):
+ return [self._normalize_json_safe(item) for item in sorted(value, key=lambda item: str(item))]
+ return str(value)
+
+ def _parse_aabb(self, value: Any) -> Dict[str, List[float]]:
+ if not isinstance(value, dict):
+ raise ValueError("AABB data must be an object with min/max coordinates.")
+ if "min" in value and "max" in value:
+ min_values = value["min"]
+ max_values = value["max"]
+ else:
+ min_values = [value.get("min_x"), value.get("min_y"), value.get("min_z")]
+ max_values = [value.get("max_x"), value.get("max_y"), value.get("max_z")]
+ min_list = self._parse_point3(min_values, "min")
+ max_list = self._parse_point3(max_values, "max")
+ for axis, (minimum, maximum) in enumerate(zip(min_list, max_list)):
+ if minimum > maximum:
+ raise ValueError(f"AABB min must be less than or equal to max on axis {axis}.")
+ return {"min": min_list, "max": max_list}
+
+ def _parse_point3(self, values: Any, label: str) -> List[float]:
+ if not isinstance(values, (list, tuple)) or len(values) != 3:
+ raise ValueError(f"AABB '{label}' must contain exactly 3 coordinates.")
+ parsed = [self._normalize_number(value) for value in values]
+ return parsed
+
+ def _aabbs_clash(
+ self,
+ first: Dict[str, List[float]],
+ second: Dict[str, List[float]],
+ tolerance: float,
+ ) -> bool:
+ for axis in range(3):
+ if first["max"][axis] + tolerance < second["min"][axis]:
+ return False
+ if second["max"][axis] + tolerance < first["min"][axis]:
+ return False
+ return True
+
+ def _relation_counts(self) -> Dict[str, int]:
+ counts: Dict[str, int] = {}
+ for _source_id, _target_id, data in self._graph.edges(data=True):
+ relation = self._normalize_relation(data.get("relation", ""))
+ counts[relation] = counts.get(relation, 0) + 1
+ return {key: counts[key] for key in sorted(counts)}
+
+ def _sort_relation_records(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+ return sorted(
+ records,
+ key=lambda item: (
+ item["source_id"],
+ item["target_id"],
+ item["relation"],
+ item["edge_key"],
+ ),
+ )
+
+ def _sort_issue_records(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+ return sorted(
+ records,
+ key=lambda item: (
+ item.get("node_id", item.get("source_id", "")),
+ item.get("target_id", ""),
+ item["issue"],
+ ),
+ )
+
+ async def shutdown(self) -> None:
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/identity_mapper.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/identity_mapper.py
new file mode 100644
index 0000000..243c7f3
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/identity_mapper.py
@@ -0,0 +1,242 @@
+import logging
+import uuid
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import ifcopenshell.guid
+
+from ..security.workspace import WorkspaceMonitor
+from .base import AECProvider, ProviderTool
+
+logger = logging.getLogger(__name__)
+
+
+def format_guid_with_hyphens(hex_str: str) -> str:
+ """Format a 32-character hex string as a standard GUID (8-4-4-4-12)."""
+ if len(hex_str) != 32:
+ return hex_str
+ return f"{hex_str[:8]}-{hex_str[8:12]}-{hex_str[12:16]}-{hex_str[16:20]}-{hex_str[20:]}"
+
+
+class AECMapperProvider(AECProvider):
+ def __init__(self, workspace: WorkspaceMonitor) -> None:
+ self.workspace = workspace
+ # Mappings registry: dict storing mapping dicts
+ self._mappings: List[Dict[str, str]] = []
+ # Index dictionaries for fast lookup
+ self._by_revit: Dict[str, Dict[str, str]] = {}
+ self._by_ifc: Dict[str, Dict[str, str]] = {}
+ self._by_rhino: Dict[str, Dict[str, str]] = {}
+ self._init_capabilities()
+
+ def get_identity(self) -> str:
+ return "mapper"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {
+ "status": "healthy",
+ "provider": "mapper",
+ "mappings_count": len(self._mappings)
+ }
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ if name == "aec_translate_id":
+ return self._translate_id(arguments)
+ elif name == "aec_register_mapping":
+ return self._register_mapping(arguments)
+ elif name == "aec_map_workspace_path":
+ return self._map_workspace_path(arguments)
+ else:
+ raise ValueError(f"Unknown tool '{name}' on mapper provider")
+
+ def _init_capabilities(self):
+ self._capabilities = [
+ ProviderTool(
+ name="aec_translate_id",
+ description="Translate an element identifier between Revit UniqueId/GUID, IFC GlobalId, and custom registered workflows.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "source_id": {"type": "string", "description": "The identifier to translate"},
+ "source_format": {
+ "type": "string",
+ "enum": ["revit_unique_id", "ifc_guid", "rhino_uuid"],
+ "description": "Format of the source identifier"
+ },
+ "target_format": {
+ "type": "string",
+ "enum": ["revit_unique_id", "ifc_guid", "rhino_uuid"],
+ "description": "Format to translate the identifier into"
+ }
+ },
+ "required": ["source_id", "source_format", "target_format"]
+ }
+ ),
+ ProviderTool(
+ name="aec_register_mapping",
+ description="Register custom relationship links between different BIM workflows (e.g. Revit element ID to Rhino object UUID).",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "mappings": {
+ "type": "array",
+ "description": "List of mapping relationships to register",
+ "items": {
+ "type": "object",
+ "properties": {
+ "revit_unique_id": {"type": "string", "description": "Revit UniqueId or GUID (optional)"},
+ "ifc_guid": {"type": "string", "description": "IFC GlobalId (optional)"},
+ "rhino_uuid": {"type": "string", "description": "Rhino/Grasshopper object UUID (optional)"}
+ }
+ }
+ }
+ },
+ "required": ["mappings"]
+ }
+ ),
+ ProviderTool(
+ name="aec_map_workspace_path",
+ description="Map and convert workspace paths between relative formats, Windows absolute format, and POSIX path format.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "path": {"type": "string", "description": "The file or directory path to convert"},
+ "target_format": {
+ "type": "string",
+ "enum": ["relative", "absolute_windows", "absolute_posix"],
+ "description": "Target string format for path conversion"
+ }
+ },
+ "required": ["path", "target_format"]
+ }
+ )
+ ]
+
+ def _translate_id(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ source_id = arguments["source_id"]
+ source_format = arguments["source_format"]
+ target_format = arguments["target_format"]
+
+ if source_format == target_format:
+ return {"translated_id": source_id}
+
+ # 1. Check custom registry first
+ custom_mapping = self._lookup_custom_mapping(source_id, source_format)
+ if custom_mapping and target_format in custom_mapping:
+ return {"translated_id": custom_mapping[target_format], "source": "custom_registry"}
+
+ # 2. Deterministic conversion between Revit UniqueId/GUID and IFC GlobalId
+ if {source_format, target_format} == {"revit_unique_id", "ifc_guid"}:
+ if source_format == "revit_unique_id":
+ try:
+ # Revit UniqueIds consist of a 36-char GUID followed by instance details (e.g., -0002ab1f)
+ guid_part = source_id[:36]
+ # Validate GUID format
+ uuid_obj = uuid.UUID(guid_part)
+ hex_str = uuid_obj.hex
+ compressed = ifcopenshell.guid.compress(hex_str)
+ return {"translated_id": compressed, "source": "deterministic_guid_compression"}
+ except Exception as e:
+ return {"translated_id": None, "error": f"Invalid Revit UniqueId/GUID: {e}"}
+
+ elif source_format == "ifc_guid":
+ try:
+ expanded_hex = ifcopenshell.guid.expand(source_id)
+ guid_with_hyphens = format_guid_with_hyphens(expanded_hex)
+ return {"translated_id": guid_with_hyphens, "source": "deterministic_ifc_expansion"}
+ except Exception as e:
+ return {"translated_id": None, "error": f"Invalid IFC GlobalId: {e}"}
+
+ return {
+ "translated_id": None,
+ "message": f"No mapping found from format '{source_format}' to '{target_format}' for ID '{source_id}'."
+ }
+
+ def _lookup_custom_mapping(self, source_id: str, format_name: str) -> Optional[Dict[str, str]]:
+ if format_name == "revit_unique_id":
+ # Check GUID prefix as well in case mapping was registered with different suffix
+ val = self._by_revit.get(source_id)
+ if not val and len(source_id) > 36:
+ val = self._by_revit.get(source_id[:36])
+ return val
+ elif format_name == "ifc_guid":
+ return self._by_ifc.get(source_id)
+ elif format_name == "rhino_uuid":
+ return self._by_rhino.get(source_id)
+ return None
+
+ def _register_mapping(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ mappings_list = arguments["mappings"]
+ count = 0
+ for m in mappings_list:
+ # Clean up mapping keys to target format names
+ mapping = {}
+ for k, v in m.items():
+ if v:
+ mapping[k] = str(v)
+
+ if not mapping:
+ continue
+
+ self._mappings.append(mapping)
+
+ # Index it
+ if "revit_unique_id" in mapping:
+ r_id = mapping["revit_unique_id"]
+ self._by_revit[r_id] = mapping
+ # Also index base 36-char GUID
+ if len(r_id) > 36:
+ self._by_revit[r_id[:36]] = mapping
+ if "ifc_guid" in mapping:
+ self._by_ifc[mapping["ifc_guid"]] = mapping
+ if "rhino_uuid" in mapping:
+ self._by_rhino[mapping["rhino_uuid"]] = mapping
+
+ count += 1
+
+ return {"status": "success", "count_registered": count}
+
+ def _map_workspace_path(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ path_str = arguments["path"]
+ target_format = arguments["target_format"]
+
+ # Assert path is within allowed directories
+ resolved_path = self.workspace.assert_in_workspace(Path(path_str))
+
+ if target_format == "relative":
+ # Return relative path to the first allowed workspace directory
+ base_dir = self.workspace.allowed_directories[0].resolve()
+ try:
+ rel = resolved_path.relative_to(base_dir)
+ return {"mapped_path": rel.as_posix()}
+ except ValueError:
+ # If not relative to the first allowed directory, try others
+ for allowed in self.workspace.allowed_directories:
+ try:
+ rel = resolved_path.relative_to(allowed.resolve())
+ return {"mapped_path": rel.as_posix()}
+ except ValueError:
+ pass
+ return {"mapped_path": resolved_path.as_posix()}
+
+ elif target_format == "absolute_windows":
+ # Ensure backslashes are used
+ return {"mapped_path": str(resolved_path).replace("/", "\\")}
+
+ elif target_format == "absolute_posix":
+ # Ensure forward slashes are used, strip drive letter if converting to clean POSIX
+ posix_path = resolved_path.as_posix()
+ # If it starts with a drive letter, e.g. C:/path, convert to /c/path
+ if len(posix_path) > 1 and posix_path[1] == ":":
+ drive = posix_path[0].lower()
+ posix_path = f"/{drive}{posix_path[2:]}"
+ return {"mapped_path": posix_path}
+
+ return {"mapped_path": str(resolved_path)}
+
+ async def shutdown(self) -> None:
+ pass
+
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/ifc.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/ifc.py
new file mode 100644
index 0000000..0e351f3
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/ifc.py
@@ -0,0 +1,538 @@
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import json
+
+import ifcopenshell
+import ifcopenshell.util
+import ifcopenshell.util.placement
+try:
+ import ifcopenshell.geom
+ HAS_GEOM = True
+except ImportError:
+ HAS_GEOM = False
+
+try:
+ import ifcopenshell.validate
+ HAS_VALIDATE = True
+except ImportError:
+ HAS_VALIDATE = False
+
+from ..security.workspace import WorkspaceMonitor
+from .base import AECProvider, ProviderTool
+
+logger = logging.getLogger(__name__)
+
+class IfcProvider(AECProvider):
+ def __init__(self, workspace: WorkspaceMonitor) -> None:
+ self.workspace = workspace
+ self._init_capabilities()
+
+ def get_identity(self) -> str:
+ return "ifc"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {
+ "status": "healthy",
+ "provider": "ifc",
+ "ifcopenshell_version": ifcopenshell.__version__ if hasattr(ifcopenshell, "__version__") else "0.7.0",
+ "has_geom": HAS_GEOM,
+ "has_validate": HAS_VALIDATE
+ }
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ if name == "ifc_health":
+ return await self.check_health()
+
+ # All other tools require an ifc_path
+ ifc_path_str = arguments.get("ifc_path")
+ if not ifc_path_str:
+ raise ValueError("Argument 'ifc_path' is required.")
+
+ resolved_path = self.workspace.assert_in_workspace(Path(ifc_path_str))
+ if not resolved_path.exists():
+ raise FileNotFoundError(f"IFC file not found: {resolved_path}")
+
+ # Open the file
+ try:
+ ifc_file = ifcopenshell.open(str(resolved_path))
+ except Exception as e:
+ raise ValueError(f"Failed to open IFC file: {e}") from e
+
+ try:
+ if name == "ifc_get_metadata":
+ return self._get_metadata(ifc_file)
+ elif name == "ifc_get_spatial_structure":
+ return self._get_spatial_structure(ifc_file)
+ elif name == "ifc_query_elements":
+ return self._query_elements(ifc_file, arguments)
+ elif name == "ifc_get_properties":
+ return self._get_properties(ifc_file, arguments)
+ elif name == "ifc_get_bounding_box":
+ return self._get_bounding_box(ifc_file, arguments)
+ elif name == "ifc_validate":
+ return self._validate(ifc_file)
+ else:
+ raise ValueError(f"Unknown IFC tool '{name}'")
+ finally:
+ # clean up references if needed (ifcopenshell files don't have explicit close in older versions, but we delete to trigger garbage collection)
+ del ifc_file
+
+ def _init_capabilities(self):
+ self._capabilities = [
+ ProviderTool(
+ name="ifc_health",
+ description="Check status of IfcOpenShell and get version info",
+ inputSchema={"type": "object", "properties": {}, "required": []}
+ ),
+ ProviderTool(
+ name="ifc_get_metadata",
+ description="Get file schema, header metadata, units, and georeferencing summary from an IFC file",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"}
+ },
+ "required": ["ifc_path"]
+ }
+ ),
+ ProviderTool(
+ name="ifc_get_spatial_structure",
+ description="Get the spatial hierarchy (Project -> Site -> Building -> Storey -> Element Types/Counts) from an IFC file",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"}
+ },
+ "required": ["ifc_path"]
+ }
+ ),
+ ProviderTool(
+ name="ifc_query_elements",
+ description="Query elements by IFC class, GUID, name, or simple property name/value criteria",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"},
+ "ifc_class": {"type": "string", "description": "IFC Class to query, e.g. 'IfcWall', 'IfcWindow' (optional)"},
+ "guid": {"type": "string", "description": "Query specific element by its GlobalId/GUID (optional)"},
+ "name_filter": {"type": "string", "description": "Sub-string filter for element name (optional)"},
+ "property_name": {"type": "string", "description": "Property name filter criteria, used with property_value (optional)"},
+ "property_value": {"description": "Property value filter criteria, used with property_name (optional)"}
+ },
+ "required": ["ifc_path"]
+ }
+ ),
+ ProviderTool(
+ name="ifc_get_properties",
+ description="Get property sets, quantities, and direct attributes for a specific element in an IFC file",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"},
+ "element_id": {"type": "string", "description": "GlobalId/GUID or Express ID of the element"}
+ },
+ "required": ["ifc_path", "element_id"]
+ }
+ ),
+ ProviderTool(
+ name="ifc_get_bounding_box",
+ description="Get bounding box dimensions and placement information for a specific element",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"},
+ "element_id": {"type": "string", "description": "GlobalId/GUID or Express ID of the element"}
+ },
+ "required": ["ifc_path", "element_id"]
+ }
+ ),
+ ProviderTool(
+ name="ifc_validate",
+ description="Perform schema validation on the IFC file and return errors/warnings list",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "ifc_path": {"type": "string", "description": "Absolute or workspace-relative path to the IFC file"}
+ },
+ "required": ["ifc_path"]
+ }
+ )
+ ]
+
+ def _get_metadata(self, ifc_file) -> Dict[str, Any]:
+ schema = ifc_file.schema
+
+ # Header Info
+ header_info = {}
+ if hasattr(ifc_file, "header") and ifc_file.header:
+ file_name = ifc_file.header.file_name
+ if file_name:
+ header_info = {
+ "name": file_name.name,
+ "timestamp": file_name.time_stamp,
+ "author": file_name.author,
+ "organization": file_name.organization,
+ "originating_system": file_name.originating_system,
+ "preprocessor_version": file_name.preprocessor_version
+ }
+
+ # Project Info
+ project = ifc_file.by_type("IfcProject")
+ project_name = project[0].Name if project else "N/A"
+ project_guid = project[0].GlobalId if project else "N/A"
+
+ # Unit Info
+ units = []
+ for ua in ifc_file.by_type("IfcUnitAssignment"):
+ for unit in ua.Units:
+ if unit.is_a("IfcSIUnit"):
+ units.append({
+ "type": unit.UnitType,
+ "name": f"{unit.Prefix or ''}{unit.Name}",
+ })
+ elif unit.is_a("IfcConversionBasedUnit"):
+ units.append({
+ "type": unit.UnitType,
+ "name": unit.Name,
+ "conversion_factor": getattr(unit.ConversionFactor.ValueComponent, "wrappedValue", str(unit.ConversionFactor.ValueComponent)) if hasattr(unit, "ConversionFactor") else None
+ })
+
+ # Georeferencing Info
+ georeferencing = {}
+ sites = ifc_file.by_type("IfcSite")
+ if sites:
+ site = sites[0]
+ lat = getattr(site, "RefLatitude", None)
+ lon = getattr(site, "RefLongitude", None)
+ elev = getattr(site, "RefElevation", None)
+ georeferencing = {
+ "latitude": self._parse_coord_tuple(lat),
+ "longitude": self._parse_coord_tuple(lon),
+ "elevation": elev
+ }
+
+ try:
+ map_conversions = ifc_file.by_type("IfcMapConversion")
+ except RuntimeError:
+ map_conversions = []
+
+ if map_conversions:
+
+ mc = map_conversions[0]
+ georeferencing["map_conversion"] = {
+ "eastings": mc.Eastings,
+ "northings": mc.Northings,
+ "orthogonal_height": mc.OrthogonalHeight,
+ "x_axis_abscissa": getattr(mc, "XAxisAbscissa", None),
+ "x_axis_ordinate": getattr(mc, "XAxisOrdinate", None),
+ "scale": getattr(mc, "Scale", None)
+ }
+
+ return {
+ "schema": schema,
+ "project_name": project_name,
+ "project_guid": project_guid,
+ "header": header_info,
+ "units": units,
+ "georeferencing": georeferencing
+ }
+
+ def _parse_coord_tuple(self, coord) -> Optional[float]:
+ if coord is None:
+ return None
+ # Lat/Lon are often represented as tuples: (degrees, minutes, seconds, microseconds)
+ if isinstance(coord, (list, tuple)):
+ try:
+ deg = float(coord[0])
+ m = float(coord[1]) if len(coord) > 1 else 0.0
+ s = float(coord[2]) if len(coord) > 2 else 0.0
+ us = float(coord[3]) if len(coord) > 3 else 0.0
+ val = deg + m / 60.0 + (s + us / 1000000.0) / 3600.0
+ # handle negative if degree was negative or separate sign
+ return val
+ except (ValueError, TypeError, IndexError):
+ return str(coord)
+ return float(coord) if isinstance(coord, (int, float)) else str(coord)
+
+ def _get_spatial_structure(self, ifc_file) -> Dict[str, Any]:
+ projects = ifc_file.by_type("IfcProject")
+ if not projects:
+ return {"message": "No IfcProject found."}
+
+ project = projects[0]
+ structure = self._build_spatial_node(project, ifc_file)
+ return {"spatial_structure": structure}
+
+ def _build_spatial_node(self, node, ifc_file) -> Dict[str, Any]:
+ info = {
+ "id": node.id(),
+ "guid": node.GlobalId,
+ "class": node.is_a(),
+ "name": node.Name or "",
+ "children": []
+ }
+
+ # Decompositions
+ for rel in getattr(node, "IsDecomposedBy", []):
+ if rel.is_a("IfcRelAggregates"):
+ for child in rel.RelatedObjects:
+ info["children"].append(self._build_spatial_node(child, ifc_file))
+
+ # Contained elements (e.g. for building storeys)
+ contained_counts = {}
+ for rel in getattr(node, "ContainsElements", []):
+ if rel.is_a("IfcRelContainedInSpatialStructure"):
+ for element in rel.RelatedElements:
+ cls = element.is_a()
+ contained_counts[cls] = contained_counts.get(cls, 0) + 1
+
+ if contained_counts:
+ info["contained_elements_summary"] = contained_counts
+
+ return info
+
+ def _query_elements(self, ifc_file, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ ifc_class = arguments.get("ifc_class") or "IfcProduct"
+ guid = arguments.get("guid")
+ name_filter = arguments.get("name_filter")
+ prop_name = arguments.get("property_name")
+ prop_val = arguments.get("property_value")
+
+ # Query by guid first
+ if guid:
+ try:
+ element = ifc_file.by_guid(guid)
+ return {"elements": [self._summarize_element(element)]}
+ except Exception:
+ return {"elements": [], "message": f"No element found with GUID {guid}"}
+
+ # Query by class
+ try:
+ elements = ifc_file.by_type(ifc_class)
+ except Exception as e:
+ raise ValueError(f"Invalid IFC class '{ifc_class}': {e}") from e
+
+ filtered_elements = []
+ for el in elements:
+ # Name filter
+ if name_filter and (not el.Name or name_filter.lower() not in el.Name.lower()):
+ continue
+
+ # Property filter
+ if prop_name:
+ has_prop = False
+ val = self._get_element_property_value(el, prop_name)
+ if val is not None:
+ if prop_val is not None:
+ # Convert to string for broad match comparison
+ if str(val).lower() == str(prop_val).lower():
+ has_prop = True
+ else:
+ has_prop = True
+ if not has_prop:
+ continue
+
+ filtered_elements.append(self._summarize_element(el))
+ if len(filtered_elements) >= 200: # Prevent oversized response limit
+ return {
+ "elements": filtered_elements,
+ "truncated": True,
+ "message": "Returned first 200 matches. Refine search criteria if needed."
+ }
+
+ return {"elements": filtered_elements}
+
+ def _summarize_element(self, element) -> Dict[str, Any]:
+ return {
+ "id": element.id(),
+ "guid": element.GlobalId,
+ "class": element.is_a(),
+ "name": element.Name or ""
+ }
+
+ def _get_element_property_value(self, element, prop_name: str) -> Any:
+ for rel in getattr(element, "IsDefinedBy", []):
+ if rel.is_a("IfcRelDefinesByProperties"):
+ prop_def = rel.RelatingPropertyDefinition
+ if prop_def.is_a("IfcPropertySet"):
+ for prop in getattr(prop_def, "HasProperties", []):
+ if prop.Name.lower() == prop_name.lower():
+ return getattr(prop, "NominalValue", None).wrappedValue if hasattr(prop, "NominalValue") else None
+ return None
+
+ def _get_properties(self, ifc_file, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ el_id = arguments.get("element_id")
+ element = self._find_element(ifc_file, el_id)
+ if not element:
+ raise ValueError(f"Element not found: {el_id}")
+
+ attributes = {}
+ try:
+ info = element.get_info()
+ for k, v in info.items():
+ if v is not None and not isinstance(v, (list, tuple)) and not hasattr(v, "id") and k not in ["id", "type"]:
+ attributes[k] = v
+ except Exception as e:
+ logger.warning(f"Failed to get element attributes: {e}")
+
+ property_sets = {}
+ quantities = {}
+
+ for rel in getattr(element, "IsDefinedBy", []):
+ if rel.is_a("IfcRelDefinesByProperties"):
+ prop_def = rel.RelatingPropertyDefinition
+ if prop_def.is_a("IfcPropertySet"):
+ pset_name = prop_def.Name
+ props = {}
+ for prop in getattr(prop_def, "HasProperties", []):
+ if prop.is_a("IfcPropertySingleValue"):
+ val = prop.NominalValue.wrappedValue if prop.NominalValue else None
+ props[prop.Name] = val
+ elif prop.is_a("IfcSimpleProperty"):
+ props[prop.Name] = str(prop)
+ property_sets[pset_name] = props
+ elif prop_def.is_a("IfcElementQuantity"):
+ qset_name = prop_def.Name
+ quants = {}
+ for q in getattr(prop_def, "Quantities", []):
+ val = None
+ if q.is_a("IfcQuantityLength"):
+ val = q.LengthValue
+ elif q.is_a("IfcQuantityArea"):
+ val = q.AreaValue
+ elif q.is_a("IfcQuantityVolume"):
+ val = q.VolumeValue
+ elif q.is_a("IfcQuantityCount"):
+ val = q.CountValue
+ elif q.is_a("IfcQuantityWeight"):
+ val = q.WeightValue
+
+ if val is not None:
+ quants[q.Name] = val
+ quantities[qset_name] = quants
+
+ return {
+ "element": self._summarize_element(element),
+ "attributes": attributes,
+ "property_sets": property_sets,
+ "quantities": quantities
+ }
+
+ def _find_element(self, ifc_file, element_id: Any):
+ if not element_id:
+ return None
+ # Try as int Express ID
+ try:
+ return ifc_file.by_id(int(element_id))
+ except (ValueError, TypeError):
+ pass
+ # Try as GlobalId/GUID
+ try:
+ return ifc_file.by_guid(str(element_id))
+ except Exception:
+ pass
+ return None
+
+ def _get_bounding_box(self, ifc_file, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ el_id = arguments.get("element_id")
+ element = self._find_element(ifc_file, el_id)
+ if not element:
+ raise ValueError(f"Element not found: {el_id}")
+
+ summary = {
+ "element": self._summarize_element(element),
+ "placement": None,
+ "bounding_box": None
+ }
+
+ # Placement extraction
+ if hasattr(element, "ObjectPlacement") and element.ObjectPlacement:
+ try:
+ matrix = ifcopenshell.util.placement.get_local_placement(element.ObjectPlacement)
+ # Convert matrix array to list
+ summary["placement"] = {
+ "matrix": matrix.tolist() if hasattr(matrix, "tolist") else list(matrix)
+ }
+ except Exception as e:
+ summary["placement_error"] = str(e)
+
+ # Bounding box geometry extraction
+ if HAS_GEOM:
+ try:
+ settings = ifcopenshell.geom.settings()
+ shape = ifcopenshell.geom.create_shape(settings, element)
+ # Compute min/max from vertices
+ verts = shape.geometry.verts
+ if verts:
+ xs = verts[0::3]
+ ys = verts[1::3]
+ zs = verts[2::3]
+ min_x, max_x = min(xs), max(xs)
+ min_y, max_y = min(ys), max(ys)
+ min_z, max_z = min(zs), max(zs)
+
+ summary["bounding_box"] = {
+ "min": [min_x, min_y, min_z],
+ "max": [max_x, max_y, max_z],
+ "size": [max_x - min_x, max_y - min_y, max_z - min_z]
+ }
+ except Exception as e:
+ summary["bounding_box_error"] = f"Failed to compute geometry: {e}"
+ else:
+ summary["bounding_box_error"] = "IfcOpenShell.geom (OpenCascade) not available in this environment."
+
+ # Fallback to structural checks if bounding box not resolved
+ if not summary["bounding_box"]:
+ # Check if element has Representation
+ rep = getattr(element, "Representation", None)
+ if rep:
+ for representation in getattr(rep, "Representations", []):
+ if representation.RepresentationType == "BoundingBox":
+ for item in representation.Items:
+ if item.is_a("IfcBoundingBox"):
+ summary["bounding_box"] = {
+ "corner": getattr(item.Corner, "Coordinates", None),
+ "x_dim": item.XDim,
+ "y_dim": item.YDim,
+ "z_dim": item.ZDim,
+ "source": "IfcBoundingBox representation"
+ }
+ break
+
+ return summary
+
+ def _validate(self, ifc_file) -> Dict[str, Any]:
+ errors = []
+ if HAS_VALIDATE:
+ try:
+ # Runs standard validation
+ for error in ifcopenshell.validate.validate(ifc_file):
+ errors.append({
+ "message": error.message,
+ "element_id": error.instance.id() if error.instance else None,
+ "element_class": error.instance.is_a() if error.instance else None
+ })
+ if len(errors) >= 100: # cap validation reports
+ break
+ except Exception as e:
+ errors.append({"message": f"Validation engine execution failed: {e}"})
+ else:
+ # Custom basic parser checks
+ # 1. Check for missing required attributes
+ # 2. Check for type mismatched attributes
+ errors.append({"message": "ifcopenshell.validate module is not available. Performing basic check: file loaded successfully."})
+
+ return {
+ "is_valid": len(errors) == 0,
+ "errors": errors,
+ "error_count": len(errors)
+ }
+
+ async def shutdown(self) -> None:
+ pass
+
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/job_provider.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/job_provider.py
new file mode 100644
index 0000000..5ed937f
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/job_provider.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ..jobs import JobManager
+from .base import AECProvider, ProviderTool
+
+
+class JobProvider(AECProvider):
+ def __init__(self, manager: JobManager) -> None:
+ self.manager = manager
+ self._capabilities = [
+ ProviderTool(
+ name="job_status",
+ description="Get the status, progress, results, or error details of a background job.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "job_id": {
+ "type": "string",
+ "description": "The unique ID of the job to query.",
+ }
+ },
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ ),
+ ProviderTool(
+ name="job_cancel",
+ description="Cancel a running or queued background job.",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "job_id": {
+ "type": "string",
+ "description": "The unique ID of the job to cancel.",
+ }
+ },
+ "required": ["job_id"],
+ "additionalProperties": False,
+ },
+ ),
+ ]
+
+ def get_identity(self) -> str:
+ return "jobs"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ return {"status": "healthy", "provider": "jobs"}
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ normalized = name.replace(".", "_")
+ if normalized == "job_status":
+ job_id = arguments["job_id"]
+ ref = await self.manager.get(job_id)
+ if ref is None:
+ raise ValueError(f"Job not found: {job_id}")
+ return ref.to_dict()
+ elif normalized == "job_cancel":
+ job_id = arguments["job_id"]
+ ref = await self.manager.cancel(job_id)
+ if ref is None:
+ raise ValueError(f"Job not found: {job_id}")
+ return ref.to_dict()
+ raise ValueError(f"Unknown job tool: {name}")
+
+ async def shutdown(self) -> None:
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/registry.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/registry.py
new file mode 100644
index 0000000..54e0809
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/registry.py
@@ -0,0 +1,35 @@
+from typing import Dict, Any, List
+import logging
+from .base import AECProvider, ProviderTool
+
+logger = logging.getLogger(__name__)
+
+class ProviderRegistry:
+ def __init__(self) -> None:
+ self._providers: Dict[str, AECProvider] = {}
+
+ def register(self, provider: AECProvider) -> None:
+ identity = provider.get_identity()
+ if identity in self._providers:
+ logger.warning(f"Overwriting already registered provider '{identity}'")
+ self._providers[identity] = provider
+ logger.info(f"Registered provider '{identity}'")
+
+ def get_provider(self, identity: str) -> AECProvider | None:
+ return self._providers.get(identity)
+
+ def get_all_providers(self) -> List[AECProvider]:
+ return list(self._providers.values())
+
+ def get_all_tools(self) -> List[ProviderTool]:
+ tools: List[ProviderTool] = []
+ for provider in self._providers.values():
+ tools.extend(provider.get_capabilities())
+ return tools
+
+ def lookup_tool_provider(self, tool_name: str) -> AECProvider | None:
+ for provider in self._providers.values():
+ for tool in provider.get_capabilities():
+ if tool.name == tool_name:
+ return provider
+ return None
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/revit.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/revit.py
new file mode 100644
index 0000000..b518d98
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/revit.py
@@ -0,0 +1,500 @@
+import json
+import logging
+from typing import Any, Dict, List
+from pathlib import Path
+
+from ..config import config, BridgeMode
+from ..errors import BridgeError
+from ..bridge.client import BridgeClient
+from ..bridge.mock import MockBridge
+from ..security.workspace import WorkspaceMonitor
+from ..tools import TOOL_HANDLERS
+from .base import AECProvider, ProviderTool
+
+logger = logging.getLogger(__name__)
+
+class RevitProvider(AECProvider):
+ def __init__(
+ self,
+ workspace: WorkspaceMonitor,
+ mode: BridgeMode = config.mode,
+ bridge_url: str | None = config.bridge_url,
+ bridge_factory=None
+ ) -> None:
+ self.workspace = workspace
+ self.mode = mode
+ self.bridge_url = bridge_url
+ self._bridge = self._build_bridge(bridge_factory)
+ self._init_tool_mapping()
+
+ def get_identity(self) -> str:
+ return "revit"
+
+ def _build_bridge(self, factory=None):
+ if self.mode == BridgeMode.bridge:
+ if not self.bridge_url:
+ raise ValueError("Bridge mode requires MCP_REVIT_BRIDGE_URL")
+ bridge_factory = factory or (lambda url: BridgeClient(url))
+ bridge = bridge_factory(self.bridge_url)
+ if hasattr(bridge, 'initialize'):
+ try:
+ bridge.initialize()
+ except Exception as e:
+ logger.error(f"Failed to initialize Revit Bridge client: {e}")
+ return bridge
+ return MockBridge()
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ # Defined below to keep the class readable.
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ if self.mode == BridgeMode.bridge:
+ try:
+ # Direct check
+ if hasattr(self._bridge, '_get'):
+ return self._bridge._get("/health")
+ return {"status": "healthy", "mode": "bridge"}
+ except Exception as e:
+ return {"status": "unhealthy", "error": str(e)}
+ return {"status": "healthy", "mode": "mock"}
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ # Check path parameters for workspace compliance
+ self._assert_paths_in_workspace(arguments)
+
+ if "." in name:
+ # Legacy dot notation (e.g. "revit.health")
+ bridge_tool = name
+ payload = arguments
+ else:
+ # MCP underscore notation (e.g. "revit_health")
+ normalized_name = name
+ if normalized_name not in self._tool_mapping:
+ raise ValueError(f"Unknown Revit tool '{name}'")
+ bridge_tool, payload_builder = self._tool_mapping[normalized_name]
+ payload = payload_builder(arguments)
+ if "request_id" in arguments and "request_id" not in payload:
+ payload["request_id"] = arguments["request_id"]
+
+ if self.mode == BridgeMode.bridge:
+ # Under bridge mode, execute the legacy handler if we need custom validation or prep
+ legacy_dot_name = bridge_tool
+ handler = TOOL_HANDLERS.get(legacy_dot_name)
+ if handler:
+ try:
+ handler(payload, self.workspace)
+ except Exception as e:
+ logger.warning(f"Revit legacy handler validation warning: {e}")
+
+ # Send to bridge client
+ return self._bridge.send_tool(bridge_tool, payload)
+ else:
+ # Mock mode
+ legacy_dot_name = bridge_tool
+ handler = TOOL_HANDLERS.get(legacy_dot_name)
+ if handler:
+ return handler(payload, self.workspace)
+
+ # Fallback to general mock response
+ return self._bridge.send_tool(bridge_tool, payload)
+
+
+ def _assert_paths_in_workspace(self, arguments: Dict[str, Any]) -> None:
+ path_keys = ["path", "csv_path", "output_path", "file_path", "template_path"]
+ for key in path_keys:
+ if key in arguments and isinstance(arguments[key], str):
+ self.workspace.assert_in_workspace(Path(arguments[key]))
+
+ def _init_tool_mapping(self):
+ self._tool_mapping = {
+ "revit_health": ("revit.health", lambda args: {}),
+ "revit_list_levels": ("revit.list_levels", lambda args: {}),
+ "revit_list_views": ("revit.list_views", lambda args: {}),
+ "revit_get_document_info": ("revit.get_document_info", lambda args: {}),
+ "revit_list_elements": ("revit.list_elements_by_category", lambda args: {
+ "category": args.get("category", "Walls")
+ }),
+ "revit_create_wall": ("revit.create_wall", lambda args: {
+ "start_point": {"x": args.get("start_x", 0), "y": args.get("start_y", 0), "z": args.get("start_z", 0)},
+ "end_point": {"x": args.get("end_x", 0), "y": args.get("end_y", 0), "z": args.get("end_z", 0)},
+ "height": args.get("height", 10),
+ "level": args.get("level", "L1")
+ }),
+ "revit_create_floor": ("revit.create_floor", lambda args: {
+ "boundary_points": [{"x": p.get("x", 0), "y": p.get("y", 0), "z": p.get("z", 0)} for p in args.get("points", [])],
+ "level": args.get("level", "L1")
+ }),
+ "revit_create_roof": ("revit.create_roof", lambda args: {
+ "boundary_points": [{"x": p.get("x", 0), "y": p.get("y", 0), "z": p.get("z", 0)} for p in args.get("points", [])],
+ "level": args.get("level", "Level 2"),
+ "slope": args.get("slope", 0.5)
+ }),
+ "revit_create_level": ("revit.create_level", lambda args: {
+ "name": args.get("name", "New Level"),
+ "elevation": args.get("elevation", 10)
+ }),
+ "revit_save_document": ("revit.save_document", lambda args: {
+ "path": args.get("path", "")
+ }),
+ "revit_create_grid": ("revit.create_grid", lambda args: {
+ "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": args.get("start_z", 0)},
+ "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": args.get("end_z", 0)},
+ "name": args.get("name")
+ }),
+ "revit_create_room": ("revit.create_room", lambda args: {
+ "level": args.get("level"),
+ "location_point": {"x": args.get("x"), "y": args.get("y"), "z": 0},
+ "name": args.get("name"),
+ "number": args.get("number")
+ }),
+ "revit_delete_element": ("revit.delete_element", lambda args: {
+ "element_id": args.get("element_id")
+ }),
+ "revit_place_family_instance": ("revit.place_family_instance", lambda args: {
+ "family_name": args.get("family_name"),
+ "type_name": args.get("type_name"),
+ "level": args.get("level"),
+ "location": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}
+ }),
+ "revit_place_door": ("revit.place_door", lambda args: {
+ "wall_id": args.get("wall_id"),
+ "family_name": args.get("family_name"),
+ "type_name": args.get("type_name"),
+ "location": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}
+ }),
+ "revit_place_window": ("revit.place_window", lambda args: {
+ "wall_id": args.get("wall_id"),
+ "family_name": args.get("family_name"),
+ "type_name": args.get("type_name"),
+ "location": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}
+ }),
+ "revit_list_families": ("revit.list_families", lambda args: {}),
+ "revit_create_floor_plan_view": ("revit.create_floor_plan_view", lambda args: {
+ "level_name": args.get("level_name"),
+ "view_name": args.get("view_name")
+ }),
+ "revit_create_3d_view": ("revit.create_3d_view", lambda args: {
+ "view_name": args.get("view_name")
+ }),
+ "revit_create_section_view": ("revit.create_section_view", lambda args: {
+ "view_name": args.get("view_name"),
+ "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": args.get("start_z", 0)},
+ "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": args.get("end_z", 0)},
+ "height": args.get("height", 10)
+ }),
+ "revit_get_element_parameters": ("revit.get_element_parameters", lambda args: {
+ "element_id": args.get("element_id")
+ }),
+ "revit_set_parameter_value": ("revit.set_parameter_value", lambda args: {
+ "element_id": args.get("element_id"),
+ "parameter_name": args.get("parameter_name"),
+ "value": args.get("value")
+ }),
+ "revit_get_parameter_value": ("revit.get_parameter_value", lambda args: {
+ "element_id": args.get("element_id"),
+ "parameter_name": args.get("parameter_name")
+ }),
+ "revit_list_shared_parameters": ("revit.list_shared_parameters", lambda args: {}),
+ "revit_create_shared_parameter": ("revit.create_shared_parameter", lambda args: {
+ "name": args.get("name"),
+ "group": args.get("group", "General"),
+ "type": args.get("type", "Text"),
+ "visible": args.get("visible", True)
+ }),
+ "revit_list_project_parameters": ("revit.list_project_parameters", lambda args: {}),
+ "revit_create_project_parameter": ("revit.create_project_parameter", lambda args: {
+ "name": args.get("name"),
+ "group": args.get("group", "General"),
+ "type": args.get("type", "Text"),
+ "category": args.get("category"),
+ "visible": args.get("visible", True)
+ }),
+ "revit_batch_set_parameters": ("revit.batch_set_parameters", lambda args: {
+ "element_ids": args.get("element_ids"),
+ "parameter_name": args.get("parameter_name"),
+ "value": args.get("value")
+ }),
+ "revit_get_type_parameters": ("revit.get_type_parameters", lambda args: {
+ "element_id": args.get("element_id")
+ }),
+ "revit_set_type_parameter": ("revit.set_type_parameter", lambda args: {
+ "element_id": args.get("element_id"),
+ "parameter_name": args.get("parameter_name"),
+ "value": args.get("value")
+ }),
+ "revit_list_sheets": ("revit.list_sheets", lambda args: {}),
+ "revit_create_sheet": ("revit.create_sheet", lambda args: {
+ "name": args.get("name"),
+ "number": args.get("number"),
+ "titleblock_id": args.get("titleblock_id")
+ }),
+ "revit_delete_sheet": ("revit.delete_sheet", lambda args: {
+ "sheet_id": args.get("sheet_id")
+ }),
+ "revit_place_viewport_on_sheet": ("revit.place_viewport_on_sheet", lambda args: {
+ "sheet_id": args.get("sheet_id"),
+ "view_id": args.get("view_id"),
+ "location": {"x": args.get("x"), "y": args.get("y"), "z": 0}
+ }),
+ "revit_batch_create_sheets_from_csv": ("revit.batch_create_sheets_from_csv", lambda args: {
+ "csv_path": args.get("csv_path"),
+ "titleblock_name": args.get("titleblock_name")
+ }),
+ "revit_populate_titleblock": ("revit.populate_titleblock", lambda args: {
+ "sheet_id": args.get("sheet_id"),
+ "parameters": args.get("parameters")
+ }),
+ "revit_list_titleblocks": ("revit.list_titleblocks", lambda args: {}),
+ "revit_get_sheet_info": ("revit.get_sheet_info", lambda args: {
+ "sheet_id": args.get("sheet_id")
+ }),
+ "revit_duplicate_sheet": ("revit.duplicate_sheet", lambda args: {
+ "sheet_id": args.get("sheet_id"),
+ "with_views": args.get("with_views", False),
+ "duplicate_option": args.get("duplicate_option", "Duplicate")
+ }),
+ "revit_renumber_sheets": ("revit.renumber_sheets", lambda args: {
+ "prefix": args.get("prefix"),
+ "start_number": args.get("start_number")
+ }),
+ "revit_get_selection": ("revit.get_selection", lambda args: {}),
+ "revit_set_selection": ("revit.set_selection", lambda args: {"element_ids": args.get("element_ids")}),
+ "revit_create_text_note": ("revit.create_text_note", lambda args: {"text": args.get("text"), "location": {"x": args.get("x"), "y": args.get("y"), "z": 0}, "view_id": args.get("view_id")}),
+ "revit_create_tag": ("revit.create_tag", lambda args: {"element_id": args.get("element_id"), "location": {"x": args.get("x"), "y": args.get("y"), "z": 0}, "view_id": args.get("view_id")}),
+ "revit_create_column": ("revit.create_column", lambda args: {"family_name": args.get("family_name"), "type_name": args.get("type_name"), "level": args.get("level"), "location": {"x": args.get("x"), "y": args.get("y"), "z": 0}}),
+ "revit_create_beam": ("revit.create_beam", lambda args: {"family_name": args.get("family_name"), "type_name": args.get("type_name"), "level": args.get("level"), "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": 0}, "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": 0}}),
+ "revit_create_foundation": ("revit.create_foundation", lambda args: {"family_name": args.get("family_name"), "type_name": args.get("type_name"), "level": args.get("level"), "location": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}}),
+ "revit_create_duct": ("revit.create_duct", lambda args: {"level": args.get("level"), "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": args.get("z", 10)}, "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": args.get("z", 10)}, "system_type": args.get("system_type"), "duct_type": args.get("duct_type")}),
+ "revit_create_pipe": ("revit.create_pipe", lambda args: {"level": args.get("level"), "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": args.get("z", 0)}, "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": args.get("z", 0)}, "system_type": args.get("system_type"), "pipe_type": args.get("pipe_type")}),
+ "revit_get_categories": ("revit.get_categories", lambda args: {}),
+ "revit_get_element_type": ("revit.get_element_type", lambda args: {"category_name": args.get("category_name"), "family_name": args.get("family_name")}),
+ "revit_close_document": ("revit.close_document", lambda args: {"save_changes": args.get("save_changes", False)}),
+ "revit_create_new_document": ("revit.create_new_document", lambda args: {"template_path": args.get("template_path")}),
+ "revit_export_dwg": ("revit.export_dwg_by_view", lambda args: {"view_id": args.get("view_id"), "output_path": args.get("output_path")}),
+ "revit_export_ifc": ("revit.export_ifc_with_settings", lambda args: {"output_path": args.get("output_path")}),
+ "revit_export_navisworks": ("revit.export_navisworks", lambda args: {"output_path": args.get("output_path")}),
+ "revit_export_image": ("revit.export_image", lambda args: {"view_id": args.get("view_id"), "output_path": args.get("output_path"), "width": args.get("width"), "height": args.get("height")}),
+ "revit_render_3d": ("revit.render_3d_view", lambda args: {"view_id": args.get("view_id"), "output_path": args.get("output_path"), "quality": args.get("quality", "Medium")}),
+ "revit_move_element": ("revit.move_element", lambda args: {"element_id": args.get("element_id"), "vector": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}}),
+ "revit_copy_element": ("revit.copy_element", lambda args: {"element_id": args.get("element_id"), "vector": {"x": args.get("x"), "y": args.get("y"), "z": args.get("z", 0)}}),
+ "revit_rotate_element": ("revit.rotate_element", lambda args: {"element_id": args.get("element_id"), "axis_point": {"x": args.get("center_x"), "y": args.get("center_y"), "z": args.get("center_z", 0)}, "angle_radians": args.get("angle_radians")}),
+ "revit_mirror_element": ("revit.mirror_element", lambda args: {"element_id": args.get("element_id"), "plane_origin": {"x": args.get("plane_origin_x"), "y": args.get("plane_origin_y"), "z": args.get("plane_origin_z", 0)}, "plane_normal": {"x": args.get("plane_normal_x"), "y": args.get("plane_normal_y"), "z": args.get("plane_normal_z", 0)}}),
+ "revit_pin_element": ("revit.pin_element", lambda args: {"element_id": args.get("element_id")}),
+ "revit_unpin_element": ("revit.unpin_element", lambda args: {"element_id": args.get("element_id")}),
+ "revit_sync_to_central": ("revit.sync_to_central", lambda args: {"comment": args.get("comment", "Sync via MCP"), "relinquish": args.get("relinquish", True)}),
+ "revit_relinquish_all": ("revit.relinquish_all", lambda args: {}),
+ "revit_get_worksets": ("revit.get_worksets", lambda args: {}),
+ "revit_create_schedule": ("revit.create_schedule", lambda args: {"category_name": args.get("category_name"), "name": args.get("name")}),
+ "revit_get_schedule_data": ("revit.get_schedule_data", lambda args: {"schedule_id": args.get("schedule_id")}),
+ "revit_get_element_bounding_box": ("revit.get_element_bounding_box", lambda args: {"element_id": args.get("element_id")}),
+ "revit_get_phases": ("revit.get_phases", lambda args: {}),
+ "revit_get_phase_filters": ("revit.get_phase_filters", lambda args: {}),
+ "revit_get_design_options": ("revit.get_design_options", lambda args: {}),
+ "revit_create_group": ("revit.create_group", lambda args: {"element_ids": args.get("element_ids"), "name": args.get("name")}),
+ "revit_ungroup": ("revit.ungroup", lambda args: {"group_id": args.get("group_id")}),
+ "revit_get_group_members": ("revit.get_group_members", lambda args: {"group_id": args.get("group_id")}),
+ "revit_get_rvt_links": ("revit.get_rvt_links", lambda args: {}),
+ "revit_get_link_instances": ("revit.get_link_instances", lambda args: {}),
+ "revit_create_conduit": ("revit.create_conduit", lambda args: {
+ "level": args.get("level"),
+ "start_point": {"x": args.get("start_x"), "y": args.get("start_y"), "z": args.get("start_z", 10)},
+ "end_point": {"x": args.get("end_x"), "y": args.get("end_y"), "z": args.get("end_z", 10)},
+ "diameter": args.get("diameter", 0.0625),
+ "conduit_type": args.get("conduit_type")
+ }),
+ "revit_check_clashes": ("revit.check_clashes", lambda args: {
+ "category1": args.get("category1"),
+ "category2": args.get("category2"),
+ "tolerance": args.get("tolerance", 0.01)
+ }),
+ "revit_create_material": ("revit.create_material", lambda args: {
+ "name": args.get("name"),
+ "color": args.get("color"),
+ "transparency": args.get("transparency", 0),
+ "shininess": args.get("shininess", 50),
+ "smoothness": args.get("smoothness", 50)
+ }),
+ "revit_set_element_material": ("revit.set_element_material", lambda args: {
+ "element_id": args.get("element_id"),
+ "material_name": args.get("material_name"),
+ "face_index": args.get("face_index")
+ }),
+ "revit_convert_to_group": ("revit.convert_to_group", lambda args: {
+ "element_ids": args.get("element_ids"),
+ "name": args.get("name")
+ }),
+ "revit_edit_family": ("revit.edit_family", lambda args: {
+ "family_name": args.get("family_name"),
+ "family_symbol_id": args.get("family_symbol_id"),
+ "family_instance_id": args.get("family_instance_id")
+ }),
+ "revit_create_dimension": ("revit.create_dimension", lambda args: {
+ "start_point": args.get("start_point"),
+ "end_point": args.get("end_point"),
+ "element1_id": args.get("element1_id"),
+ "element2_id": args.get("element2_id")
+ }),
+ "revit_get_revision_sequences": ("revit.get_revision_sequences", lambda args: {}),
+ "revit_tag_all_in_view": ("revit.tag_all_in_view", lambda args: {"category": args.get("category")}),
+ "revit_get_view_templates": ("revit.get_view_templates", lambda args: {}),
+ "revit_apply_view_template": ("revit.apply_view_template", lambda args: {
+ "view_id": args.get("view_id"),
+ "template_id": args.get("template_id")
+ }),
+ "revit_calculate_material_quantities": ("revit.calculate_material_quantities", lambda args: {"category": args.get("category")}),
+ "revit_get_warnings": ("revit.get_warnings", lambda args: {}),
+ "revit_invoke_method": ("revit.invoke_method", lambda args: {
+ "class_name": args.get("class_name"),
+ "method_name": args.get("method_name"),
+ "arguments": args.get("arguments"),
+ "target_id": args.get("target_id"),
+ "use_transaction": args.get("use_transaction", True)
+ }),
+ "revit_reflect_get": ("revit.reflect_get", lambda args: {
+ "target_id": args.get("target_id"),
+ "property_name": args.get("property_name")
+ }),
+ "revit_reflect_set": ("revit.reflect_set", lambda args: {
+ "target_id": args.get("target_id"),
+ "property_name": args.get("property_name"),
+ "value": args.get("value")
+ }),
+ "revit_execute_python": ("revit.execute_python", lambda args: {
+ "script": args.get("script")
+ }),
+ "revit_change_element_type": ("revit.change_element_type", lambda args: {
+ "source_type_id": args.get("source_type_id"),
+ "target_type_id": args.get("target_type_id"),
+ "category": args.get("category")
+ }),
+ "revit_get_elements_by_type": ("revit.get_elements_by_type", lambda args: {
+ "type_id": args.get("type_id"),
+ "category": args.get("category"),
+ "level": args.get("level"),
+ "fields": args.get("fields"),
+ "offset": args.get("offset", 0),
+ "limit": args.get("limit", 200)
+ }),
+ "revit_batch_set_parameters_by_filter": ("revit.batch_set_parameters_by_filter", lambda args: {
+ "filter": args.get("filter"),
+ "parameter_name": args.get("parameter_name"),
+ "value": args.get("value")
+ }),
+ "revit_replace_family_type": ("revit.replace_family_type", lambda args: {
+ "old_family": args.get("old_family"),
+ "old_type": args.get("old_type"),
+ "new_family": args.get("new_family"),
+ "new_type": args.get("new_type")
+ }),
+ "revit_get_element_geometry": ("revit.get_element_geometry", lambda args: {
+ "element_id": args.get("element_id")
+ }),
+ }
+
+ # Define _capabilities schema list
+ _capabilities = [
+ ProviderTool(name="revit_health", description="Check if Revit is running and get status information", inputSchema={"type": "object", "properties": {}, "required": []}),
+ ProviderTool(name="revit_create_wall", description="Create a wall in Revit between two points", inputSchema={"type": "object", "properties": {"start_x": {"type": "number", "description": "Start point X coordinate in feet"}, "start_y": {"type": "number", "description": "Start point Y coordinate in feet"}, "start_z": {"type": "number", "description": "Start point Z coordinate in feet", "default": 0}, "end_x": {"type": "number", "description": "End point X coordinate in feet"}, "end_y": {"type": "number", "description": "End point Y coordinate in feet"}, "end_z": {"type": "number", "description": "End point Z coordinate in feet", "default": 0}, "height": {"type": "number", "description": "Wall height in feet", "default": 10}, "level": {"type": "string", "description": "Level name (e.g., 'L1', 'L2')", "default": "L1"}}, "required": ["start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_create_floor", description="Create a floor in Revit with a rectangular or custom boundary", inputSchema={"type": "object", "properties": {"points": {"type": "array", "description": "Array of boundary points [{x, y, z}]. Minimum 3 points for a closed boundary.", "items": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["x", "y"]}}, "level": {"type": "string", "description": "Level name", "default": "L1"}}, "required": ["points"]}),
+ ProviderTool(name="revit_create_roof", description="Create a roof in Revit", inputSchema={"type": "object", "properties": {"points": {"type": "array", "description": "Array of boundary points for the roof", "items": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}}, "level": {"type": "string", "description": "Level name"}, "slope": {"type": "number", "description": "Roof slope", "default": 0.5}}, "required": ["points", "level"]}),
+ ProviderTool(name="revit_list_levels", description="List all levels in the Revit project", inputSchema={"type": "object", "properties": {}, "required": []}),
+ ProviderTool(name="revit_list_views", description="List all views in the Revit project", inputSchema={"type": "object", "properties": {}, "required": []}),
+ ProviderTool(name="revit_list_elements", description="List elements by category (Walls, Floors, Roofs, Doors, Windows, etc.)", inputSchema={"type": "object", "properties": {"category": {"type": "string", "description": "Category name (e.g., 'Walls', 'Floors', 'Doors')"}}, "required": ["category"]}),
+ ProviderTool(name="revit_get_document_info", description="Get information about the active Revit document", inputSchema={"type": "object", "properties": {}, "required": []}),
+ ProviderTool(name="revit_create_level", description="Create a new level in Revit", inputSchema={"type": "object", "properties": {"name": {"type": "string", "description": "Level name"}, "elevation": {"type": "number", "description": "Elevation in feet"}}, "required": ["name", "elevation"]}),
+ ProviderTool(name="revit_save_document", description="Save the current Revit document", inputSchema={"type": "object", "properties": {"path": {"type": "string", "description": "File path to save to (optional for existing files)"}}}),
+ ProviderTool(name="revit_create_grid", description="Create a grid line in Revit", inputSchema={"type": "object", "properties": {"start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 0}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 0}, "name": {"type": "string"}}, "required": ["start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_create_room", description="Create a room at a specific point on a level", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "name": {"type": "string", "default": "Room"}, "number": {"type": "string"}}, "required": ["level", "x", "y"]}),
+ ProviderTool(name="revit_delete_element", description="Delete an element by ID", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_place_family_instance", description="Place a family instance (e.g., furniture, equipment)", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["family_name", "type_name", "level", "x", "y"]}),
+ ProviderTool(name="revit_place_door", description="Place a door in a wall", inputSchema={"type": "object", "properties": {"wall_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}, "family_name": {"type": "string"}, "type_name": {"type": "string"}}, "required": ["wall_id", "x", "y"]}),
+ ProviderTool(name="revit_place_window", description="Place a window in a wall", inputSchema={"type": "object", "properties": {"wall_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}, "family_name": {"type": "string"}, "type_name": {"type": "string"}}, "required": ["wall_id", "x", "y"]}),
+ ProviderTool(name="revit_list_families", description="List all loaded families and their types", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_floor_plan_view", description="Create a floor plan view for a level", inputSchema={"type": "object", "properties": {"level_name": {"type": "string"}, "view_name": {"type": "string"}}, "required": ["level_name"]}),
+ ProviderTool(name="revit_create_3d_view", description="Create a new 3D view", inputSchema={"type": "object", "properties": {"view_name": {"type": "string"}}, "required": ["view_name"]}),
+ ProviderTool(name="revit_create_section_view", description="Create a section view", inputSchema={"type": "object", "properties": {"view_name": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number"}, "height": {"type": "number", "default": 10}}, "required": ["start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_get_element_parameters", description="Get all parameters of an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_set_parameter_value", description="Set a parameter value for an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "parameter_name": {"type": "string"}, "value": {"type": ["string", "number", "boolean"]}}, "required": ["element_id", "parameter_name", "value"]}),
+ ProviderTool(name="revit_get_parameter_value", description="Get a specific parameter value", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "parameter_name": {"type": "string"}}, "required": ["element_id", "parameter_name"]}),
+ ProviderTool(name="revit_list_shared_parameters", description="List shared parameters in the document", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_shared_parameter", description="Create a new shared parameter", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "group": {"type": "string"}, "type": {"type": "string"}, "visible": {"type": "boolean"}}, "required": ["name"]}),
+ ProviderTool(name="revit_list_project_parameters", description="List project parameters", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_project_parameter", description="Create a new project parameter", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "category": {"type": "string"}, "group": {"type": "string"}, "type": {"type": "string"}}, "required": ["name", "category"]}),
+ ProviderTool(name="revit_batch_set_parameters", description="Set a parameter value for multiple elements", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "parameter_name": {"type": "string"}, "value": {"type": ["string", "number"]}}, "required": ["element_ids", "parameter_name", "value"]}),
+ ProviderTool(name="revit_get_type_parameters", description="Get type parameters for an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_set_type_parameter", description="Set a type parameter value", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "parameter_name": {"type": "string"}, "value": {"type": ["string", "number"]}}, "required": ["element_id", "parameter_name", "value"]}),
+ ProviderTool(name="revit_list_sheets", description="List all sheets", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_sheet", description="Create a new sheet", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "number": {"type": "string"}, "titleblock_id": {"type": "integer"}}, "required": ["name", "number"]}),
+ ProviderTool(name="revit_delete_sheet", description="Delete a sheet", inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}}, "required": ["sheet_id"]}),
+ ProviderTool(name="revit_place_viewport_on_sheet", description="Place a view on a sheet", inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}, "view_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}}, "required": ["sheet_id", "view_id", "x", "y"]}),
+ ProviderTool(name="revit_batch_create_sheets_from_csv", description="Create multiple sheets from a CSV file", inputSchema={"type": "object", "properties": {"csv_path": {"type": "string"}, "titleblock_name": {"type": "string"}}, "required": ["csv_path"]}),
+ ProviderTool(name="revit_populate_titleblock", description="Populate titleblock parameters", inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}, "parameters": {"type": "object"}}, "required": ["sheet_id", "parameters"]}),
+ ProviderTool(name="revit_list_titleblocks", description="List available titleblocks", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_sheet_info", description="Get detailed information about a sheet", inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}}, "required": ["sheet_id"]}),
+ ProviderTool(name="revit_duplicate_sheet", description="Duplicate a sheet", inputSchema={"type": "object", "properties": {"sheet_id": {"type": "integer"}, "with_views": {"type": "boolean"}, "duplicate_option": {"type": "string"}}, "required": ["sheet_id"]}),
+ ProviderTool(name="revit_renumber_sheets", description="Batch renumber sheets", inputSchema={"type": "object", "properties": {"prefix": {"type": "string"}, "start_number": {"type": "integer"}}, "required": ["start_number"]}),
+ ProviderTool(name="revit_get_selection", description="Get currently selected element IDs", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_set_selection", description="Set selection by element IDs", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}}, "required": ["element_ids"]}),
+ ProviderTool(name="revit_create_text_note", description="Create a text note", inputSchema={"type": "object", "properties": {"text": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "view_id": {"type": "integer"}}, "required": ["text", "x", "y"]}),
+ ProviderTool(name="revit_create_tag", description="Tag an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "view_id": {"type": "integer"}}, "required": ["element_id", "x", "y"]}),
+ ProviderTool(name="revit_create_column", description="Create structural column", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}}, "required": ["family_name", "type_name", "level", "x", "y"]}),
+ ProviderTool(name="revit_create_beam", description="Create structural beam", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}}, "required": ["family_name", "type_name", "level", "start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_create_foundation", description="Create foundation", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "type_name": {"type": "string"}, "level": {"type": "string"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["family_name", "type_name", "level", "x", "y"]}),
+ ProviderTool(name="revit_create_duct", description="Create duct", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "z": {"type": "number", "default": 10}, "system_type": {"type": "string"}, "duct_type": {"type": "string"}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_create_pipe", description="Create pipe", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "z": {"type": "number", "default": 0}, "system_type": {"type": "string"}, "pipe_type": {"type": "string"}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_get_categories", description="List Revit categories", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_element_type", description="Find element types/families", inputSchema={"type": "object", "properties": {"category_name": {"type": "string"}, "family_name": {"type": "string"}}, "required": ["category_name"]}),
+ ProviderTool(name="revit_close_document", description="Close active document", inputSchema={"type": "object", "properties": {"save_changes": {"type": "boolean", "default": False}}}),
+ ProviderTool(name="revit_create_new_document", description="Create new project", inputSchema={"type": "object", "properties": {"template_path": {"type": "string"}}}),
+ ProviderTool(name="revit_export_dwg", description="Export view to DWG", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}}, "required": ["view_id", "output_path"]}),
+ ProviderTool(name="revit_export_ifc", description="Export to IFC", inputSchema={"type": "object", "properties": {"output_path": {"type": "string"}}, "required": ["output_path"]}),
+ ProviderTool(name="revit_export_navisworks", description="Export to NWC", inputSchema={"type": "object", "properties": {"output_path": {"type": "string"}}, "required": ["output_path"]}),
+ ProviderTool(name="revit_export_image", description="Export view to Image", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}, "width": {"type": "integer"}, "height": {"type": "integer"}}, "required": ["view_id", "output_path"]}),
+ ProviderTool(name="revit_render_3d", description="Render 3D view to image", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "output_path": {"type": "string"}, "quality": {"type": "string", "enum": ["Draft", "Medium", "High"]}}, "required": ["view_id", "output_path"]}),
+ ProviderTool(name="revit_move_element", description="Move an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["element_id", "x", "y"]}),
+ ProviderTool(name="revit_copy_element", description="Copy an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number", "default": 0}}, "required": ["element_id", "x", "y"]}),
+ ProviderTool(name="revit_rotate_element", description="Rotate an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "center_x": {"type": "number"}, "center_y": {"type": "number"}, "center_z": {"type": "number", "default": 0}, "angle_radians": {"type": "number"}}, "required": ["element_id", "center_x", "center_y", "angle_radians"]}),
+ ProviderTool(name="revit_mirror_element", description="Mirror an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "plane_origin_x": {"type": "number"}, "plane_origin_y": {"type": "number"}, "plane_origin_z": {"type": "number", "default": 0}, "plane_normal_x": {"type": "number"}, "plane_normal_y": {"type": "number"}, "plane_normal_z": {"type": "number", "default": 0}}, "required": ["element_id", "plane_origin_x", "plane_origin_y", "plane_normal_x", "plane_normal_y"]}),
+ ProviderTool(name="revit_pin_element", description="Pin an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_unpin_element", description="Unpin an element", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_sync_to_central", description="Sync to central model", inputSchema={"type": "object", "properties": {"comment": {"type": "string"}, "relinquish": {"type": "boolean", "default": True}}}),
+ ProviderTool(name="revit_relinquish_all", description="Relinquish all elements and worksets", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_worksets", description="Get all worksets", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_schedule", description="Create a schedule", inputSchema={"type": "object", "properties": {"category_name": {"type": "string"}, "name": {"type": "string"}}, "required": ["category_name", "name"]}),
+ ProviderTool(name="revit_get_schedule_data", description="Get schedule data", inputSchema={"type": "object", "properties": {"schedule_id": {"type": "integer"}}, "required": ["schedule_id"]}),
+ ProviderTool(name="revit_get_element_bounding_box", description="Get element bounding box", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}}, "required": ["element_id"]}),
+ ProviderTool(name="revit_get_phases", description="Get project phases", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_phase_filters", description="Get phase filters", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_design_options", description="Get design options", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_group", description="Create a group", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "name": {"type": "string"}}, "required": ["element_ids", "name"]}),
+ ProviderTool(name="revit_ungroup", description="Ungroup a group", inputSchema={"type": "object", "properties": {"group_id": {"type": "integer"}}, "required": ["group_id"]}),
+ ProviderTool(name="revit_get_group_members", description="Get group members", inputSchema={"type": "object", "properties": {"group_id": {"type": "integer"}}, "required": ["group_id"]}),
+ ProviderTool(name="revit_get_rvt_links", description="Get RVT links", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_get_link_instances", description="Get link instances", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_create_conduit", description="Create electrical conduit", inputSchema={"type": "object", "properties": {"level": {"type": "string"}, "start_x": {"type": "number"}, "start_y": {"type": "number"}, "start_z": {"type": "number", "default": 10}, "end_x": {"type": "number"}, "end_y": {"type": "number"}, "end_z": {"type": "number", "default": 10}, "diameter": {"type": "number", "default": 0.0625}}, "required": ["level", "start_x", "start_y", "end_x", "end_y"]}),
+ ProviderTool(name="revit_check_clashes", description="Check clashes between categories", inputSchema={"type": "object", "properties": {"category1": {"type": "string"}, "category2": {"type": "string"}, "tolerance": {"type": "number", "default": 0.01}}, "required": ["category1", "category2"]}),
+ ProviderTool(name="revit_create_material", description="Create a new material with color and properties", inputSchema={"type": "object", "properties": {"name": {"type": "string"}, "color": {"type": "object", "properties": {"r": {"type": "integer"}, "g": {"type": "integer"}, "b": {"type": "integer"}}}, "transparency": {"type": "integer", "default": 0}, "shininess": {"type": "integer", "default": 50}, "smoothness": {"type": "integer", "default": 50}}, "required": ["name"]}),
+ ProviderTool(name="revit_set_element_material", description="Set material for an element or specific face", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer"}, "material_name": {"type": "string"}, "face_index": {"type": "integer", "description": "Optional face index for face-specific material"}}, "required": ["element_id", "material_name"]}),
+ ProviderTool(name="revit_convert_to_group", description="Convert elements into a group", inputSchema={"type": "object", "properties": {"element_ids": {"type": "array", "items": {"type": "integer"}}, "name": {"type": "string"}}, "required": ["element_ids"]}),
+ ProviderTool(name="revit_edit_family", description="Open a family for editing", inputSchema={"type": "object", "properties": {"family_name": {"type": "string"}, "family_symbol_id": {"type": "integer"}, "family_instance_id": {"type": "integer"}}, "required": []}),
+ ProviderTool(name="revit_create_dimension", description="Create linear dimension between elements", inputSchema={"type": "object", "properties": {"start_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "end_point": {"type": "object", "properties": {"x": {"type": "number"}, "y": {"type": "number"}, "z": {"type": "number"}}}, "element1_id": {"type": "integer"}, "element2_id": {"type": "integer"}}, "required": ["start_point", "end_point", "element1_id", "element2_id"]}),
+ ProviderTool(name="revit_get_revision_sequences", description="Get list of revision sequences", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_tag_all_in_view", description="Tag all elements of a category in view", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
+ ProviderTool(name="revit_get_view_templates", description="Get list of view templates", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_apply_view_template", description="Apply view template to a view", inputSchema={"type": "object", "properties": {"view_id": {"type": "integer"}, "template_id": {"type": "integer"}}, "required": ["view_id", "template_id"]}),
+ ProviderTool(name="revit_calculate_material_quantities", description="Calculate material volumes for a category", inputSchema={"type": "object", "properties": {"category": {"type": "string"}}, "required": ["category"]}),
+ ProviderTool(name="revit_get_warnings", description="Get current project warnings", inputSchema={"type": "object", "properties": {}}),
+ ProviderTool(name="revit_invoke_method", description="Invoke any Revit API method dynamically using Reflection", inputSchema={"type": "object", "properties": {"class_name": {"type": "string"}, "method_name": {"type": "string"}, "arguments": {"type": "array", "items": {}}, "target_id": {"type": "string"}, "use_transaction": {"type": "boolean", "default": True}}, "required": ["class_name", "method_name", "arguments"]}),
+ ProviderTool(name="revit_reflect_get", description="Get any Revit property value dynamically", inputSchema={"type": "object", "properties": {"target_id": {"type": "string"}, "property_name": {"type": "string"}}, "required": ["target_id", "property_name"]}),
+ ProviderTool(name="revit_reflect_set", description="Set any Revit property value dynamically", inputSchema={"type": "object", "properties": {"target_id": {"type": "string"}, "property_name": {"type": "string"}, "value": {}}, "required": ["target_id", "property_name", "value"]}),
+ ProviderTool(name="revit_execute_python", description="Execute arbitrary Python/IronPython code inside Revit with broad access to the public Revit API.", inputSchema={"type": "object", "properties": {"script": {"type": "string", "description": "Python script to execute"}}, "required": ["script"]}),
+ ProviderTool(name="revit_change_element_type", description="Swap all instances of one element type to another type.", inputSchema={"type": "object", "properties": {"source_type_id": {"type": "integer", "description": "Element type ID to replace (all instances)"}, "target_type_id": {"type": "integer", "description": "Element type ID to change to"}, "category": {"type": "string", "description": "Optional category filter (e.g. 'Walls', 'Doors') to limit scope"}}, "required": ["source_type_id", "target_type_id"]}),
+ ProviderTool(name="revit_get_elements_by_type", description="Get element IDs and key parameters, filtered by type, category, and/or level.", inputSchema={"type": "object", "properties": {"type_id": {"type": "integer", "description": "Filter by element type ID (optional)"}, "category": {"type": "string", "description": "Filter by category name, e.g. 'Walls', 'Doors' (optional)"}, "level": {"type": "string", "description": "Filter by level name, e.g. 'BG', 'L1' (optional)"}, "fields": {"type": "array", "items": {"type": "string"}, "description": "Fields to return: id always included. Options: name, category, type_id, level, length, area, volume"}, "offset": {"type": "integer", "description": "Pagination offset (default 0)", "default": 0}, "limit": {"type": "integer", "description": "Max results to return (default 200, max 500)", "default": 200}}, "required": []}),
+ ProviderTool(name="revit_batch_set_parameters_by_filter", description="Set a parameter value on all elements matching a filter (category, type, level, or parameter value).", inputSchema={"type": "object", "properties": {"filter": {"type": "object", "description": "Filter criteria to select elements", "properties": {"category": {"type": "string", "description": "Category name, e.g. 'Walls'"}, "type_id": {"type": "integer", "description": "Element type ID filter"}, "level": {"type": "string", "description": "Level name filter"}, "parameter_filter": {"type": "object", "description": "Only include elements where this parameter equals this value", "properties": {"name": {"type": "string"}, "value": {}}, "required": ["name", "value"]}}}, "parameter_name": {"type": "string", "description": "Name of the parameter to set"}, "value": {"description": "Value to set (string, number, or boolean)"}}, "required": ["filter", "parameter_name", "value"]}),
+ ProviderTool(name="revit_replace_family_type", description="Replace all instances of one family/type combination with another, identified by name.", inputSchema={"type": "object", "properties": {"old_family": {"type": "string", "description": "Current family name (exact match, case-insensitive)"}, "old_type": {"type": "string", "description": "Current type name"}, "new_family": {"type": "string", "description": "Replacement family name"}, "new_type": {"type": "string", "description": "Replacement type name"}}, "required": ["old_family", "old_type", "new_family", "new_type"]}),
+ ProviderTool(name="revit_get_element_geometry", description="Get geometric data for an element: location point or curve endpoints, bounding box, level, area, volume, and length.", inputSchema={"type": "object", "properties": {"element_id": {"type": "integer", "description": "Element ID"}}, "required": ["element_id"]})
+ ]
+
+ async def shutdown(self) -> None:
+ pass
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/providers/rhino.py b/packages/mcp-server-revit/src/revit_mcp_server/providers/rhino.py
new file mode 100644
index 0000000..68ecc1a
--- /dev/null
+++ b/packages/mcp-server-revit/src/revit_mcp_server/providers/rhino.py
@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import base64
+import os
+from urllib.parse import urlparse
+from pathlib import Path
+from typing import Any, Dict, List, Mapping, Sequence
+
+import httpx
+
+from ..errors import BridgeError, WorkspaceViolation
+from ..security.workspace import WorkspaceMonitor
+from .base import AECProvider, ProviderTool
+
+
+class RhinoProvider(AECProvider):
+ SUPPORTED_DEFINITION_EXTENSIONS = {".gh", ".ghx"}
+ SUPPORTED_GEOMETRY_EXTENSIONS = {".3dm"}
+
+ def __init__(
+ self,
+ workspace: WorkspaceMonitor,
+ base_url: str | None = None,
+ api_key: str | None = None,
+ api_key_header: str = "RhinoComputeKey",
+ client: httpx.AsyncClient | None = None,
+ timeout: float = 30.0,
+ grasshopper_prefix: str = "/grasshopper",
+ rhino_prefix: str = "/rhino",
+ io_path: str = "/io",
+ solve_path: str = "/solve",
+ geometry_query_path: str = "/query_file_geometry",
+ layers_path: str = "/layers",
+ geometry_details_path: str = "/geometry_details",
+ max_upload_bytes: int | None = None,
+ ) -> None:
+ self.workspace = workspace
+ self.base_url = (base_url or os.getenv("MCP_RHINO_COMPUTE_URL") or os.getenv("RHINO_COMPUTE_URL") or "https://localhost:5001").rstrip("/")
+ self._enforce_base_url_policy(self.base_url)
+ self.api_key = api_key or os.getenv("MCP_RHINO_COMPUTE_KEY") or os.getenv("RHINO_COMPUTE_KEY")
+ self.api_key_header = api_key_header
+ self.timeout = timeout
+ self.max_upload_bytes = self._resolve_max_upload_bytes(max_upload_bytes)
+ self._own_client = client is None
+ self._client = client or httpx.AsyncClient(base_url=self.base_url, timeout=timeout, follow_redirects=True)
+ self._grasshopper_prefix = self._normalize_prefix(grasshopper_prefix)
+ self._rhino_prefix = self._normalize_prefix(rhino_prefix)
+ self._io_path = self._normalize_suffix(io_path)
+ self._solve_path = self._normalize_suffix(solve_path)
+ self._geometry_query_path = self._normalize_suffix(geometry_query_path)
+ self._layers_path = self._normalize_suffix(layers_path)
+ self._geometry_details_path = self._normalize_suffix(geometry_details_path)
+ self._init_capabilities()
+
+ def get_identity(self) -> str:
+ return "rhino"
+
+ def get_capabilities(self) -> List[ProviderTool]:
+ return self._capabilities
+
+ async def check_health(self) -> Dict[str, Any]:
+ response = await self._request_json("GET", "/health")
+ return response
+
+ async def execute_tool(self, name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+ normalized = name.replace(".", "_")
+ if normalized == "rhino_health":
+ return await self.check_health()
+ if normalized == "rhino_get_definition_io":
+ definition_path = self._require_path(arguments, "definition_path", self.SUPPORTED_DEFINITION_EXTENSIONS)
+ return await self._definition_io(definition_path)
+ if normalized == "rhino_evaluate_definition":
+ definition_path = self._require_path(arguments, "definition_path", self.SUPPORTED_DEFINITION_EXTENSIONS)
+ input_trees = self._validate_input_trees(arguments.get("input_trees"))
+ return await self._evaluate_definition(definition_path, input_trees)
+ if normalized == "rhino_query_file_geometry":
+ file_path = self._require_path(arguments, "file_path", self.SUPPORTED_GEOMETRY_EXTENSIONS)
+ return await self._query_file_geometry(file_path, arguments)
+ if normalized == "rhino_get_layers":
+ file_path = self._require_path(arguments, "file_path", self.SUPPORTED_GEOMETRY_EXTENSIONS)
+ return await self._get_layers(file_path)
+ if normalized == "rhino_get_geometry_details":
+ file_path = self._require_path(arguments, "file_path", self.SUPPORTED_GEOMETRY_EXTENSIONS)
+ return await self._get_geometry_details(file_path, arguments)
+ raise ValueError(f"Unknown Rhino tool '{name}'")
+
+ async def shutdown(self) -> None:
+ if self._own_client:
+ await self._client.aclose()
+
+ def _init_capabilities(self) -> None:
+ self._capabilities = [
+ ProviderTool(
+ name="rhino_health",
+ description="Check Rhino.Compute connectivity and service status",
+ inputSchema={"type": "object", "properties": {}, "required": []},
+ ),
+ ProviderTool(
+ name="rhino_get_definition_io",
+ description="Upload a Grasshopper definition and return its Resthopper input/output metadata",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "definition_path": {
+ "type": "string",
+ "description": "Workspace path to a .gh or .ghx Grasshopper definition",
+ }
+ },
+ "required": ["definition_path"],
+ },
+ ),
+ ProviderTool(
+ name="rhino_evaluate_definition",
+ description="Upload a Grasshopper definition, solve it against Resthopper-compatible trees, and return the compute response",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "definition_path": {
+ "type": "string",
+ "description": "Workspace path to a .gh or .ghx Grasshopper definition",
+ },
+ "input_trees": {
+ "type": "array",
+ "description": "Resthopper-compatible input trees",
+ "items": {
+ "type": "object",
+ "properties": {
+ "ParamName": {"type": "string"},
+ "InnerTree": {"type": "object"},
+ },
+ "required": ["ParamName", "InnerTree"],
+ },
+ },
+ },
+ "required": ["definition_path"],
+ },
+ ),
+ ProviderTool(
+ name="rhino_query_file_geometry",
+ description="Upload a .3dm file and query geometry summaries through Rhino.Compute",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "file_path": {
+ "type": "string",
+ "description": "Workspace path to a .3dm file",
+ },
+ "include_hidden": {
+ "type": "boolean",
+ "default": False,
+ "description": "Include hidden objects when querying geometry",
+ },
+ },
+ "required": ["file_path"],
+ },
+ ),
+ ProviderTool(
+ name="rhino_get_layers",
+ description="Return layer metadata for a .3dm file through Rhino.Compute",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "file_path": {
+ "type": "string",
+ "description": "Workspace path to a .3dm file",
+ }
+ },
+ "required": ["file_path"],
+ },
+ ),
+ ProviderTool(
+ name="rhino_get_geometry_details",
+ description="Return detailed geometry metadata for a .3dm file through Rhino.Compute",
+ inputSchema={
+ "type": "object",
+ "properties": {
+ "file_path": {
+ "type": "string",
+ "description": "Workspace path to a .3dm file",
+ }
+ },
+ "required": ["file_path"],
+ },
+ ),
+ ]
+
+ def _normalize_prefix(self, prefix: str) -> str:
+ cleaned = prefix.strip()
+ if not cleaned:
+ return ""
+ return "/" + cleaned.strip("/")
+
+ def _normalize_suffix(self, suffix: str) -> str:
+ cleaned = suffix.strip()
+ if not cleaned:
+ return ""
+ return "/" + cleaned.strip("/")
+
+ def _build_endpoint(self, prefix: str, suffix: str) -> str:
+ if not prefix:
+ return suffix or "/"
+ if not suffix:
+ return prefix
+ return f"{prefix}{suffix}"
+
+ def _require_path(self, arguments: Mapping[str, Any], key: str, allowed_extensions: Sequence[str]) -> Path:
+ raw_path = arguments.get(key)
+ if not isinstance(raw_path, str) or not raw_path.strip():
+ raise ValueError(f"Argument '{key}' is required.")
+ try:
+ resolved = self.workspace.assert_in_workspace(Path(raw_path))
+ except WorkspaceViolation as exc:
+ raise ValueError("Path is outside the allowed workspace.") from exc
+ if resolved.suffix.lower() not in {ext.lower() for ext in allowed_extensions}:
+ raise ValueError(
+ f"Unsupported Rhino file extension '{resolved.suffix or '<none>'}' for '{resolved.name}'."
+ )
+ if not resolved.exists():
+ raise FileNotFoundError(f"Rhino file not found: {resolved.name}")
+ return resolved
+
+ def _validate_input_trees(self, input_trees: Any) -> list[dict[str, Any]]:
+ if input_trees is None:
+ return []
+ if not isinstance(input_trees, list):
+ raise ValueError("Argument 'input_trees' must be a list when provided.")
+ validated: list[dict[str, Any]] = []
+ for index, tree in enumerate(input_trees):
+ if not isinstance(tree, dict):
+ raise ValueError(f"Input tree at index {index} must be an object.")
+ if "ParamName" not in tree or "InnerTree" not in tree:
+ raise ValueError(f"Input tree at index {index} must include 'ParamName' and 'InnerTree'.")
+ validated.append(tree)
+ return validated
+
+ def _tree_to_resthopper_values(self, input_trees: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
+ return [dict(tree) for tree in input_trees]
+
+ def _file_payload(self, file_path: Path) -> dict[str, Any]:
+ self._enforce_upload_size(file_path)
+ return {
+ "file_name": file_path.name,
+ "file_data": base64.b64encode(file_path.read_bytes()).decode("ascii"),
+ }
+
+ async def _definition_io(self, definition_path: Path) -> Dict[str, Any]:
+ payload = self._file_payload(definition_path)
+ response = await self._request_json(
+ "POST",
+ self._build_endpoint(self._grasshopper_prefix, self._io_path),
+ payload=payload,
+ )
+ return response
+
+ async def _evaluate_definition(self, definition_path: Path, input_trees: Sequence[Mapping[str, Any]]) -> Dict[str, Any]:
+ io_response = await self._definition_io(definition_path)
+ definition_id = (
+ io_response.get("definition_id")
+ or io_response.get("id")
+ or io_response.get("DefinitionId")
+ or io_response.get("DefinitionID")
+ )
+ if not definition_id:
+ raise BridgeError("Rhino.Compute did not return a definition identifier from the IO endpoint.")
+
+ solve_payload = {
+ "definition_id": definition_id,
+ "input_trees": self._tree_to_resthopper_values(input_trees),
+ }
+ return await self._request_json(
+ "POST",
+ self._build_endpoint(self._grasshopper_prefix, self._solve_path),
+ payload=solve_payload,
+ )
+
+ async def _query_file_geometry(self, file_path: Path, arguments: Mapping[str, Any]) -> Dict[str, Any]:
+ payload = self._file_payload(file_path)
+ payload["include_hidden"] = bool(arguments.get("include_hidden", False))
+ return await self._request_json(
+ "POST",
+ self._build_endpoint(self._rhino_prefix, self._geometry_query_path),
+ payload=payload,
+ )
+
+ async def _get_layers(self, file_path: Path) -> Dict[str, Any]:
+ payload = self._file_payload(file_path)
+ return await self._request_json(
+ "POST",
+ self._build_endpoint(self._rhino_prefix, self._layers_path),
+ payload=payload,
+ )
+
+ async def _get_geometry_details(self, file_path: Path, arguments: Mapping[str, Any]) -> Dict[str, Any]:
+ payload = self._file_payload(file_path)
+ if "object_ids" in arguments:
+ payload["object_ids"] = arguments["object_ids"]
+ return await self._request_json(
+ "POST",
+ self._build_endpoint(self._rhino_prefix, self._geometry_details_path),
+ payload=payload,
+ )
+
+ async def _request_json(self, method: str, endpoint: str, *, payload: dict[str, Any] | None = None) -> Dict[str, Any]:
+ headers = {}
+ if self.api_key:
+ headers[self.api_key_header] = self.api_key
+ try:
+ response = await self._client.request(method, endpoint, json=payload, headers=headers)
+ response.raise_for_status()
+ response_payload = response.json()
+ except httpx.HTTPStatusError as exc:
+ raise BridgeError(f"Rhino.Compute request to {endpoint} failed with status {exc.response.status_code}") from exc
+ except httpx.RequestError as exc:
+ raise BridgeError(f"Rhino.Compute request to {endpoint} failed: {exc.__class__.__name__}") from exc
+ except ValueError as exc:
+ raise BridgeError(f"Rhino.Compute response from {endpoint} was not valid JSON") from exc
+ if not isinstance(response_payload, dict):
+ raise BridgeError(f"Rhino.Compute response from {endpoint} was not a JSON object")
+ return response_payload
+
+ def _enforce_upload_size(self, file_path: Path) -> None:
+ if file_path.stat().st_size > self.max_upload_bytes:
+ raise ValueError(
+ f"Rhino file '{file_path.name}' exceeds the maximum upload size of {self.max_upload_bytes} bytes."
+ )
+
+ def _enforce_base_url_policy(self, base_url: str) -> None:
+ parsed = urlparse(base_url)
+ if parsed.scheme not in {"http", "https"}:
+ raise ValueError("Rhino.Compute base URL must use http or https.")
+ if parsed.scheme == "http" and not self._is_loopback_host(parsed.hostname):
+ raise ValueError("Rhino.Compute base URL must use https unless the host is localhost or 127.0.0.1.")
+
+ def _is_loopback_host(self, hostname: str | None) -> bool:
+ return hostname in {"localhost", "127.0.0.1", "::1"}
+
+ def _resolve_max_upload_bytes(self, max_upload_bytes: int | None) -> int:
+ if max_upload_bytes is not None:
+ return int(max_upload_bytes)
+ env_value = os.getenv("MCP_RHINO_COMPUTE_MAX_UPLOAD_BYTES") or os.getenv("RHINO_COMPUTE_MAX_UPLOAD_BYTES")
+ if env_value:
+ return int(env_value)
+ return 50 * 1024 * 1024
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/security/audit.py b/packages/mcp-server-revit/src/revit_mcp_server/security/audit.py
index f69bd04..c0baf29 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/security/audit.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/security/audit.py
@@ -1,11 +1,60 @@
-from __future__ import annotations
-
import json
+import re
from datetime import datetime, timezone
from pathlib import Path
+from typing import Any, Mapping
from ..schemas import HealthOutput
+_SECRET_KEYS = {
+ "authorization",
+ "accesstoken",
+ "refreshtoken",
+ "idtoken",
+ "token",
+ "password",
+ "clientsecret",
+ "secret",
+ "codeverifier",
+ "apikey",
+ "authorizationcode",
+ "code",
+ "rhinocomputekey",
+}
+
+_SECRET_VALUE_RE = re.compile(
+ r"(?i)\b(api[_-]?key|token|secret|password|passwd|session|authorization|rhinocomputekey)\b\s*[:=]\s*([^\s,;]+)"
+)
+_WINDOWS_PATH_RE = re.compile(r"(?<!\w)(?:[A-Za-z]:[\\/](?:[^\s\"'<>|]+[\\/])*[^\s\"'<>|]+)")
+_POSIX_PATH_RE = re.compile(r"(?:(?<=^)|(?<=[\s\"'(<\[]))(/(?:[^/\s]+/)*[^/\s]+)")
+
+
+def _is_sensitive_key(key: str) -> bool:
+ normalized = re.sub(r"[^a-z0-9]", "", key.strip().lower())
+ return normalized in _SECRET_KEYS
+
+
+def _redact_text(value: str) -> str:
+ sanitized = _SECRET_VALUE_RE.sub(lambda match: f"{match.group(1)}=<redacted>", value)
+ sanitized = _WINDOWS_PATH_RE.sub("<redacted-path>", sanitized)
+ sanitized = _POSIX_PATH_RE.sub("<redacted-path>", sanitized)
+ return sanitized
+
+
+def redact_data(value: Any, key: str | None = None) -> Any:
+ if key and _is_sensitive_key(key):
+ return "<redacted>"
+ if isinstance(value, Mapping):
+ return {str(item_key): redact_data(item_value, str(item_key)) for item_key, item_value in value.items()}
+ if isinstance(value, list):
+ return [redact_data(item) for item in value]
+ if isinstance(value, tuple):
+ return tuple(redact_data(item) for item in value)
+ if isinstance(value, str):
+ return _redact_text(value)
+ return value
+
+
class AuditRecorder:
def __init__(self, path: Path):
self.path = path
@@ -16,8 +65,9 @@ class AuditRecorder:
"timestamp": datetime.now(timezone.utc).isoformat(),
"tool": tool,
"request_id": request_id,
- "payload": payload,
- "response": response,
+ "payload": redact_data(payload),
+ "response": redact_data(response),
}
with self.path.open("a", encoding="utf-8") as fh:
fh.write(json.dumps(entry) + "\n")
+
diff --git a/packages/mcp-server-revit/src/revit_mcp_server/server.py b/packages/mcp-server-revit/src/revit_mcp_server/server.py
index 9673914..7cb9382 100644
--- a/packages/mcp-server-revit/src/revit_mcp_server/server.py
+++ b/packages/mcp-server-revit/src/revit_mcp_server/server.py
@@ -1,15 +1,30 @@
from __future__ import annotations
+import asyncio
import io
import json
+import logging
import sys
+import threading
from typing import Callable, Dict, Protocol
-from .bridge import BridgeClient, MockBridge
from .config import BridgeMode, Config, config
-from .security.audit import AuditRecorder
+from .security.audit import AuditRecorder, redact_data
from .security.workspace import WorkspaceMonitor
-from .tools import TOOL_HANDLERS
+from .providers import (
+ ProviderRegistry,
+ RevitProvider,
+ IfcProvider,
+ AECMapperProvider,
+ RhinoProvider,
+ SemanticGraphProvider,
+ SpeckleProvider,
+ AutodeskDataProvider,
+ JobProvider,
+)
+from .jobs import JobManager
+
+logger = logging.getLogger(__name__)
class BridgeTransport(Protocol):
@@ -34,34 +49,100 @@ class MCPServer:
self.config = config_obj if config_obj is not None else config
self.workspace = WorkspaceMonitor(self.config.allowed_directories)
self.audit = AuditRecorder(self.config.audit_log)
- self.handlers: Dict[str, Callable[[dict, WorkspaceMonitor], dict]] = TOOL_HANDLERS
- self.bridge = self._build_bridge(bridge_factory)
- def _build_bridge(
- self,
- factory: Callable[[str], BridgeTransport] | None,
- ) -> BridgeTransport:
- if self.config.mode == BridgeMode.bridge:
- if not self.config.bridge_url:
- raise ValueError("Bridge mode requires MCP_REVIT_BRIDGE_URL")
- bridge_factory = factory or (lambda url: BridgeClient(url))
- bridge = bridge_factory(self.config.bridge_url)
- # Initialize bridge connection and fetch tool catalog
- if hasattr(bridge, 'initialize'):
- bridge.initialize()
- return bridge
- return MockBridge()
+ # Initialize the persistent background event loop for job execution survival
+ self._loop = asyncio.new_event_loop()
+ self._loop_thread = threading.Thread(target=self._run_loop, daemon=True)
+ self._loop_thread.start()
+
+ # Initialize and register providers behind the scenes
+ self.registry = ProviderRegistry()
+ self.revit_provider = RevitProvider(
+ workspace=self.workspace,
+ mode=self.config.mode,
+ bridge_url=self.config.bridge_url,
+ bridge_factory=bridge_factory
+ )
+ self.registry.register(self.revit_provider)
+ self.registry.register(IfcProvider(workspace=self.workspace))
+ self.registry.register(AECMapperProvider(workspace=self.workspace))
+
+ # Register Job Provider
+ self.job_manager = JobManager()
+ self.registry.register(JobProvider(manager=self.job_manager))
+
+ # Register other providers conditionally
+ try:
+ self.registry.register(RhinoProvider(workspace=self.workspace))
+ except Exception as e:
+ logger.warning("Could not initialize RhinoProvider: %s", e)
+
+ try:
+ self.registry.register(SemanticGraphProvider())
+ except Exception as e:
+ logger.warning("Could not initialize SemanticGraphProvider: %s", e)
+
+ try:
+ self.registry.register(SpeckleProvider())
+ except Exception as e:
+ logger.warning("Could not initialize SpeckleProvider: %s. Please set SPECKLE_CLIENT_ID.", e)
+
+ try:
+ self.registry.register(AutodeskDataProvider())
+ except Exception as e:
+ logger.warning("Could not initialize AutodeskDataProvider: %s. Please set APS_CLIENT_ID.", e)
+
+ def _run_loop(self) -> None:
+ asyncio.set_event_loop(self._loop)
+ self._loop.run_forever()
def handle_tool(self, tool_name: str, payload: dict) -> dict:
- handler = self.handlers.get(tool_name)
- if handler is None:
+ # Resolve the provider for the tool
+ normalized_name = tool_name.replace(".", "_")
+ provider = self.registry.lookup_tool_provider(normalized_name)
+ if not provider:
+ if tool_name.startswith("ifc") or tool_name.startswith("ifc."):
+ provider = self.registry.get_provider("ifc")
+ else:
+ provider = self.registry.get_provider("revit")
+
+ if provider is None:
raise ValueError(f"Unknown tool {tool_name}")
- if self.config.mode == BridgeMode.bridge:
- handler(payload, self.workspace)
- response = self.bridge.send_tool(tool_name, payload)
- else:
- response = handler(payload, self.workspace)
+ # Check if deferred execution is requested
+ run_async = False
+ idempotency_key = None
+ if isinstance(payload, dict):
+ args_copy = dict(payload)
+ run_async = args_copy.pop("run_async", False)
+ if isinstance(run_async, str):
+ run_async = run_async.lower() in ("true", "1", "yes")
+ run_async = bool(run_async)
+ idempotency_key = args_copy.get("idempotency_key")
+
+ try:
+ if run_async:
+ async def run_tool_job(context=None):
+ return await provider.execute_tool(tool_name, payload)
+
+ # Submit the job on the background loop
+ future = asyncio.run_coroutine_threadsafe(
+ self.job_manager.submit(run_tool_job, idempotency_key=idempotency_key),
+ self._loop
+ )
+ job_ref = future.result()
+ response = job_ref.to_dict()
+ else:
+ # Run normally on the background loop
+ future = asyncio.run_coroutine_threadsafe(
+ provider.execute_tool(tool_name, payload),
+ self._loop
+ )
+ response = future.result()
+
+ response = redact_data(response)
+ except Exception as exc:
+ response = {"status": "error", "message": redact_data(str(exc))}
self.audit.record(tool_name, payload.get("request_id", ""), payload, response)
return response
@@ -77,19 +158,44 @@ class MCPServer:
stdout.write("AEC Model Bridge server started. Awaiting JSON requests.\n")
stdout.flush()
- while line := stdin.readline():
- line = line.strip()
- if not line:
- continue
- try:
- request = json.loads(line)
- tool = request.get("tool")
- payload = request.get("payload", {})
- response = self.handle_tool(tool, payload)
- except Exception as exc: # noqa: BLE001
- response = {"status": "error", "message": str(exc)}
- stdout.write(json.dumps({"tool": tool, "response": response}) + "\n")
- stdout.flush()
+ try:
+ while line := stdin.readline():
+ line = line.strip()
+ if not line:
+ continue
+ try:
+ request = json.loads(line)
+ tool = request.get("tool")
+ payload = request.get("payload", {})
+ response = self.handle_tool(tool, payload)
+ except Exception as exc: # noqa: BLE001
+ response = {"status": "error", "message": redact_data(str(exc))}
+ stdout.write(json.dumps({"tool": tool, "response": response}) + "\n")
+ stdout.flush()
+ finally:
+ self.shutdown()
+
+ def shutdown(self) -> None:
+ # Gracefully stop the JobManager and any running jobs
+ future = asyncio.run_coroutine_threadsafe(
+ self.job_manager.shutdown(cancel_running=True),
+ self._loop
+ )
+ try:
+ future.result(timeout=2.0)
+ except Exception:
+ pass
+
+ # Close provider clients
+ for p in self.registry._providers.values():
+ if hasattr(p, "shutdown"):
+ try:
+ asyncio.run_coroutine_threadsafe(p.shutdown(), self._loop).result(timeout=1.0)
+ except Exception:
+ pass
+
+ self._loop.call_soon_threadsafe(self._loop.stop)
+ self._loop_thread.join(timeout=2.0)
def run_server() -> None:
diff --git a/packages/mcp-server-revit/tests/test_cloud_providers.py b/packages/mcp-server-revit/tests/test_cloud_providers.py
new file mode 100644
index 0000000..f5175c0
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_cloud_providers.py
@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+import httpx
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from revit_mcp_server.providers.cloud import (
+ AutodeskDataProvider,
+ OAuthTokenBundle,
+ SpeckleProvider,
+)
+
+
+def _json_response(payload: dict, status_code: int = 200) -> httpx.Response:
+ return httpx.Response(status_code=status_code, json=payload)
+
+
+async def test_speckle_oauth_pkce_exchange_and_state_validation() -> None:
+ seen_requests: list[httpx.Request] = []
+
+ def handler(request: httpx.Request) -> httpx.Response:
+ seen_requests.append(request)
+ assert request.url == httpx.URL("https://speckle.example/auth/token")
+ form = parse_qs(request.content.decode("utf-8"))
+ assert form["grant_type"] == ["authorization_code"]
+ assert form["code"] == ["oauth-code-123"]
+ assert form["code_verifier"][0]
+ assert "client_id" not in form
+ assert request.headers["Authorization"].startswith("Basic ")
+ return _json_response(
+ {
+ "access_token": "speckle-access-token",
+ "refresh_token": "speckle-refresh-token",
+ "expires_in": 3600,
+ "token_type": "Bearer",
+ "scope": "profile:read streams:read",
+ }
+ )
+
+ provider = SpeckleProvider(
+ host="https://speckle.example",
+ client_id="speckle-client",
+ client_secret="speckle-secret",
+ redirect_uri="http://localhost/callback",
+ allow_localhost_http=True,
+ oauth_transport=httpx.MockTransport(handler),
+ oauth_pending_state_ttl_seconds=1,
+ oauth_max_pending_states=2,
+ )
+
+ start = await provider.execute_tool("speckle.oauth_start", {})
+ parsed = urlparse(start["authorization_url"])
+ params = parse_qs(parsed.query)
+ assert parsed.scheme == "https"
+ assert params["response_type"] == ["code"]
+ assert start["state"] == params["state"][0]
+ assert params["code_challenge_method"] == ["S256"]
+ assert "code_challenge" in params
+
+ exchanged = await provider.execute_tool(
+ "speckle_oauth_exchange_code",
+ {"code": "oauth-code-123", "state": start["state"]},
+ )
+ assert exchanged["authorized"] is True
+ assert exchanged["has_refresh_token"] is True
+ assert "access_token" not in exchanged
+ assert len(seen_requests) == 1
+
+ status = await provider.execute_tool("speckle_auth_status", {})
+ assert status["authorized"] is True
+
+ with pytest.raises(ValueError, match="OAuth state validation failed"):
+ await provider.execute_tool(
+ "speckle_oauth_exchange_code",
+ {"code": "oauth-code-123", "state": "wrong-state"},
+ )
+
+ await provider.shutdown()
+
+
+async def test_oauth_pending_state_ttl_pruning_and_bounded_count() -> None:
+ provider = AutodeskDataProvider(
+ client_id="aps-client",
+ client_secret="aps-secret",
+ redirect_uri="http://localhost/callback",
+ allow_localhost_http=True,
+ oauth_pending_state_ttl_seconds=3600,
+ oauth_max_pending_states=2,
+ )
+
+ start_one = await provider.execute_tool("autodesk_data_oauth_start", {})
+ start_two = await provider.execute_tool("autodesk_data_oauth_start", {})
+ assert start_one["state"] != start_two["state"]
+
+ with pytest.raises(ValueError, match="Too many pending OAuth states"):
+ await provider.execute_tool("autodesk_data_oauth_start", {})
+
+ for pending in provider.oauth._pending_states.values():
+ pending.created_at = 0
+
+ start_three = await provider.execute_tool("autodesk_data_oauth_start", {})
+ assert start_three["state"]
+ assert len(provider.oauth._pending_states) == 1
+
+ await provider.shutdown()
+
+
+async def test_autodesk_refresh_uses_callback_credentials_and_no_tool_token_args() -> None:
+ seen_requests: list[httpx.Request] = []
+
+ async def credential_callback(name: str) -> str | None:
+ if name == "client_secret":
+ return "aps-secret"
+ if name == "refresh_token":
+ return "callback-refresh-token"
+ return None
+
+ def handler(request: httpx.Request) -> httpx.Response:
+ seen_requests.append(request)
+ form = parse_qs(request.content.decode("utf-8"))
+ assert form["grant_type"] == ["refresh_token"]
+ assert form["refresh_token"] == ["callback-refresh-token"]
+ assert "client_id" not in form
+ assert request.headers["Authorization"].startswith("Basic ")
+ return _json_response(
+ {
+ "access_token": "aps-access-token",
+ "refresh_token": "aps-refresh-token",
+ "expires_in": 1800,
+ "token_type": "Bearer",
+ "scope": "data:read data:write",
+ }
+ )
+
+ provider = AutodeskDataProvider(
+ client_id="aps-client",
+ redirect_uri="http://localhost/callback",
+ allow_localhost_http=True,
+ credential_callback=credential_callback,
+ oauth_transport=httpx.MockTransport(handler),
+ )
+
+ refreshed = await provider.execute_tool("autodesk_data_oauth_refresh", {})
+ assert refreshed["authorized"] is True
+ assert refreshed["has_refresh_token"] is True
+ assert len(seen_requests) == 1
+
+ await provider.shutdown()
+
+
+async def test_speckle_graphql_calls_auth_headers_idempotency_and_merge_configuration() -> None:
+ seen_requests: list[httpx.Request] = []
+
+ def handler(request: httpx.Request) -> httpx.Response:
+ seen_requests.append(request)
+ assert request.headers["Authorization"] == "Bearer token-123"
+ payload = request.read().decode("utf-8")
+ if "SpeckleProjects" in payload:
+ return _json_response({"data": {"activeUser": {"projects": {"items": [{"id": "p1", "name": "Project 1"}]}}}})
+ if "SpeckleCreateModel" in payload:
+ assert request.headers["Idempotency-Key"] == "idem-001"
+ return _json_response({"data": {"projectMutations": {"modelCreate": {"id": "m1", "name": "Model 1", "description": None}}}})
+ if "ConfiguredSpeckleMerge" in payload:
+ return _json_response({"data": {"customMerge": {"ok": True}}})
+ raise AssertionError(payload)
+
+ provider_without_merge = SpeckleProvider(
+ host="https://speckle.example",
+ client_id="speckle-client",
+ client_secret="speckle-secret",
+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+ )
+ provider_without_merge.oauth._token_bundle = OAuthTokenBundle(access_token="token-123", refresh_token="refresh-123")
+
+ listed = await provider_without_merge.execute_tool("speckle_list_projects", {"limit": 10})
+ assert listed["projects"][0]["id"] == "p1"
+
+ created = await provider_without_merge.execute_tool(
+ "speckle_create_model",
+ {"project_id": "p1", "name": "Model 1", "idempotency_key": "idem-001"},
+ )
+ assert created["model"]["id"] == "m1"
+
+ request_count_before_merge = len(seen_requests)
+ with pytest.raises(NotImplementedError, match="merge_operation_builder"):
+ await provider_without_merge.execute_tool(
+ "speckle_merge_model",
+ {
+ "project_id": "p1",
+ "source_model_id": "m-source",
+ "target_model_id": "m-target",
+ "message": "merge now",
+ },
+ )
+ assert len(seen_requests) == request_count_before_merge
+ await provider_without_merge.shutdown()
+
+ def merge_builder(arguments: dict) -> dict:
+ return {
+ "query": """
+ mutation ConfiguredSpeckleMerge($projectId:String!, $source:String!, $target:String!, $message:String!) {
+ customMerge(projectId:$projectId, source:$source, target:$target, message:$message) { ok }
+ }
+ """,
+ "variables": {
+ "projectId": arguments["project_id"],
+ "source": arguments["source_model_id"],
+ "target": arguments["target_model_id"],
+ "message": arguments["message"],
+ },
+ "result_path": ["customMerge", "ok"],
+ }
+
+ provider_with_merge = SpeckleProvider(
+ host="https://speckle.example",
+ client_id="speckle-client",
+ client_secret="speckle-secret",
+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+ merge_operation_builder=merge_builder,
+ )
+ provider_with_merge.oauth._token_bundle = OAuthTokenBundle(access_token="token-123", refresh_token="refresh-123")
+
+ merged = await provider_with_merge.execute_tool(
+ "speckle_merge_branch",
+ {
+ "project_id": "p1",
+ "source_model_id": "m-source",
+ "target_model_id": "m-target",
+ "message": "merge now",
+ },
+ )
+ assert merged["merged"] is True
+
+ assert len(seen_requests) == 3
+ await provider_with_merge.shutdown()
+
+
+async def test_autodesk_rest_calls_bcf_validation_idempotency_and_redaction() -> None:
+ seen_requests: list[httpx.Request] = []
+
+ def handler(request: httpx.Request) -> httpx.Response:
+ seen_requests.append(request)
+ assert request.headers["Authorization"] == "Bearer aps-token"
+ if request.method == "GET" and request.url.path == "/project/v1/hubs":
+ return _json_response({"data": [{"id": "hub-1"}]})
+ if request.method == "GET" and str(request.url).endswith("/data/v1/projects/project%2F1/versions/version%201"):
+ return _json_response({"data": {"id": "version-1", "type": "versions"}})
+ if request.method == "POST" and request.url.path == "/issues/v1/topics":
+ assert request.headers["Idempotency-Key"] == "topic-001"
+ return _json_response(
+ {
+ "topicId": "topic-1",
+ "Authorization": "should-not-leak",
+ "access_token": "should-not-leak",
+ "snapshot": r"C:\Users\sammo\secret.png",
+ }
+ )
+ raise AssertionError(f"Unexpected request: {request.method} {request.url}")
+
+ provider = AutodeskDataProvider(
+ client_id="aps-client",
+ client_secret="aps-secret",
+ issues_endpoint="https://developer.api.autodesk.com/issues/v1/topics",
+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler)),
+ )
+ provider.oauth._token_bundle = OAuthTokenBundle(access_token="aps-token", refresh_token="refresh-token")
+
+ hubs = await provider.execute_tool("autodesk_data_list_hubs", {})
+ assert hubs["hubs"][0]["id"] == "hub-1"
+
+ version = await provider.execute_tool(
+ "autodesk_data_get_version_metadata",
+ {"project_id": "project/1", "version_id": "version 1"},
+ )
+ assert version["version"]["id"] == "version-1"
+
+ created = await provider.execute_tool(
+ "autodesk_data_create_topic",
+ {
+ "container_id": "container-1",
+ "title": "Coordination issue",
+ "description": "Beam clashes with duct",
+ "status": "open",
+ "type": "issue",
+ "ifc_guid_refs": ["0J$w1A2B3C4D5E6F7G8H9I"],
+ "viewpoint": {"guid": "view-1", "snapshot_url": "https://example.com/view.png", "index": 0},
+ "idempotency_key": "topic-001",
+ },
+ )
+ assert created["topicId"] == "topic-1"
+ assert created["Authorization"] == "<redacted>"
+ assert created["access_token"] == "<redacted>"
+ assert created["snapshot"] == "<redacted-path>"
+
+ with pytest.raises(ValueError, match="Invalid IFC GUID reference"):
+ await provider.execute_tool(
+ "autodesk_data_create_topic",
+ {
+ "container_id": "container-1",
+ "title": "Bad issue",
+ "description": "Bad guid",
+ "ifc_guid_refs": ["not-a-guid"],
+ },
+ )
+
+ items_seen: list[httpx.Request] = []
+
+ def item_handler(request: httpx.Request) -> httpx.Response:
+ items_seen.append(request)
+ assert str(request.url).endswith("/data/v1/projects/project%2F1/folders/folder%201%2Fchild/contents")
+ return _json_response({"data": []})
+
+ item_provider = AutodeskDataProvider(
+ client_id="aps-client",
+ client_secret="aps-secret",
+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(item_handler)),
+ )
+ item_provider.oauth._token_bundle = OAuthTokenBundle(access_token="aps-token", refresh_token="refresh-token")
+ await item_provider.execute_tool(
+ "autodesk_data_list_items",
+ {"project_id": "project/1", "folder_id": "folder 1/child"},
+ )
+ assert len(items_seen) == 1
+
+ await item_provider.shutdown()
+ await provider.shutdown()
+
+
+async def test_redaction_in_errors_and_https_enforcement() -> None:
+ def failing_handler(request: httpx.Request) -> httpx.Response:
+ return httpx.Response(status_code=500, json={"error": "failed"})
+
+ provider = AutodeskDataProvider(
+ client_id="aps-client",
+ client_secret="aps-secret",
+ issues_endpoint="https://developer.api.autodesk.com/issues/v1/topics",
+ http_client=httpx.AsyncClient(transport=httpx.MockTransport(failing_handler)),
+ )
+ provider.oauth._token_bundle = OAuthTokenBundle(access_token="aps-token", refresh_token="refresh-token")
+
+ with pytest.raises(RuntimeError) as exc:
+ await provider.execute_tool(
+ "autodesk_data_create_topic",
+ {
+ "container_id": "container-1",
+ "title": "Broken issue",
+ "description": "Payload should fail cleanly",
+ "viewpoint": {"snapshot_url": "failed at C:\\Users\\sammo\\Desktop\\secret.png and /Users/sammo/private/file.bcfv"},
+ },
+ )
+
+ assert r"C:\Users\sammo\Desktop\secret.png" not in str(exc.value)
+ assert "/Users/sammo/private/file.bcfv" not in str(exc.value)
+ assert "<redacted-path>" in str(exc.value)
+
+ with pytest.raises(ValueError, match="must use HTTPS"):
+ SpeckleProvider(
+ host="http://speckle.example",
+ client_id="speckle-client",
+ client_secret="speckle-secret",
+ )
+
+ localhost_provider = SpeckleProvider(
+ host="https://speckle.example",
+ client_id="speckle-client",
+ client_secret="speckle-secret",
+ redirect_uri="http://localhost/callback",
+ allow_localhost_http=True,
+ )
+ await localhost_provider.shutdown()
+ await provider.shutdown()
diff --git a/packages/mcp-server-revit/tests/test_graph_provider.py b/packages/mcp-server-revit/tests/test_graph_provider.py
new file mode 100644
index 0000000..94550bc
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_graph_provider.py
@@ -0,0 +1,294 @@
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+ sys.path.insert(0, str(SRC))
+
+import pytest
+
+from revit_mcp_server.providers.graph import SemanticGraphProvider
+
+
+def sample_graph_payload():
+ return {
+ "nodes": [
+ {
+ "id": "wall-1",
+ "type": "Wall",
+ "attributes": {"load_bearing": True},
+ "aabb": {"min": [0.0, 0.0, 0.0], "max": [1.0, 1.0, 1.0]},
+ },
+ {
+ "id": "wall-2",
+ "type": "Wall",
+ "attributes": {"load_bearing": True},
+ "aabb": {"min": [0.5, 0.5, 0.5], "max": [1.5, 1.5, 1.5]},
+ },
+ {
+ "id": "slab-1",
+ "type": "Slab",
+ "attributes": {"requires_support": True},
+ "aabb": {"min": [3.0, 0.0, 0.0], "max": [4.0, 1.0, 1.0]},
+ },
+ {
+ "id": "slab-2",
+ "type": "Slab",
+ "attributes": {"requires_support": True},
+ "aabb": {"min": [5.0, 0.0, 0.0], "max": [6.0, 1.0, 1.0]},
+ },
+ {
+ "id": "beam-1",
+ "type": "Beam",
+ "attributes": {"load_bearing": False, "is_support": True},
+ "aabb": {"min": [3.0, 0.0, -1.0], "max": [4.0, 1.0, 0.0]},
+ },
+ {
+ "id": "pipe-1",
+ "type": "Pipe",
+ "attributes": {},
+ "aabb": {"min": [10.0, 10.0, 10.0], "max": [11.0, 11.0, 11.0]},
+ },
+ {
+ "id": "material-1",
+ "type": "Material",
+ "attributes": {},
+ "aabb": {"min": [20.0, 20.0, 20.0], "max": [21.0, 21.0, 21.0]},
+ },
+ ],
+ "edges": [
+ {"source": "wall-1", "target": "wall-2", "relation": "CONNECTED_TO"},
+ {"source": "wall-1", "target": "slab-1", "relation": "ADJACENT_TO"},
+ {"source": "slab-1", "target": "beam-1", "relation": "SUPPORTED_BY"},
+ ],
+ }
+
+
+async def test_graph_compile_relations_and_health():
+ provider = SemanticGraphProvider()
+
+ compiled = await provider.execute_tool("graph_compile", sample_graph_payload())
+ assert compiled["status"] == "success"
+ assert compiled["compiled"]["nodes_received"] == 7
+ assert compiled["compiled"]["edges_received"] == 3
+ assert compiled["compiled"]["nodes_total"] == 7
+ assert compiled["compiled"]["edges_total"] == 3
+
+ health = await provider.check_health()
+ assert health["status"] == "healthy"
+ assert health["nodes"] == 7
+ assert health["edges"] == 3
+ assert health["relation_counts"] == {
+ "ADJACENT_TO": 1,
+ "CONNECTED_TO": 1,
+ "SUPPORTED_BY": 1,
+ }
+
+ added = await provider.execute_tool(
+ "graph_add_relation",
+ {
+ "source_id": "wall-2",
+ "target_id": "material-1",
+ "relation": "HAS_MATERIAL",
+ "attributes": {"confidence": 1.0},
+ },
+ )
+ assert added["status"] == "success"
+ assert added["relation"]["relation"] == "HAS_MATERIAL"
+ assert added["relation"]["source_id"] == "wall-2"
+
+ query = await provider.execute_tool(
+ "graph_query_relations",
+ {
+ "node_id": "wall-1",
+ "direction": "outgoing",
+ "limit": 1,
+ },
+ )
+ assert query["status"] == "success"
+ assert query["count"] == 1
+ assert query["total"] == 2
+ assert query["truncated"] is True
+ assert query["relations"][0]["source_id"] == "wall-1"
+ assert query["relations"][0]["relation"] == "ADJACENT_TO"
+
+ repeat = await provider.execute_tool(
+ "graph_query_relations",
+ {"node_id": "wall-1", "direction": "outgoing", "limit": 1},
+ )
+ assert repeat == query
+
+
+async def test_graph_audits():
+ provider = SemanticGraphProvider()
+ await provider.execute_tool("graph_compile", sample_graph_payload())
+ await provider.execute_tool(
+ "graph_add_relation",
+ {
+ "source_id": "wall-2",
+ "target_id": "material-1",
+ "relation": "HAS_MATERIAL",
+ },
+ )
+
+ clash_audit = await provider.execute_tool(
+ "graph_audit_clashes",
+ {
+ "node_ids": ["wall-1", "wall-2", "material-1"],
+ "tolerance": 0.0,
+ "limit": 10,
+ },
+ )
+ assert clash_audit["status"] == "success"
+ assert clash_audit["count"] == 1
+ assert clash_audit["total"] == 1
+ assert clash_audit["clashes"][0]["node_a"] == "wall-1"
+ assert clash_audit["clashes"][0]["node_b"] == "wall-2"
+
+ disconnected = await provider.execute_tool(
+ "graph_audit_disconnected",
+ {
+ "node_types": ["Wall", "Pipe"],
+ "relation_types": ["CONNECTED_TO", "ADJACENT_TO"],
+ "min_degree": 1,
+ "limit": 10,
+ },
+ )
+ assert disconnected["status"] == "success"
+ assert disconnected["disconnected_nodes"] == ["pipe-1"]
+ assert disconnected["components"] == [["pipe-1"], ["wall-1", "wall-2"]]
+
+ structural = await provider.execute_tool(
+ "graph_audit_structural_loads",
+ {
+ "node_types": ["Slab", "Beam"],
+ "limit": 10,
+ },
+ )
+ assert structural["status"] == "success"
+ assert any(issue["issue"] == "missing_support" and issue["node_id"] == "slab-2" for issue in structural["issues"])
+ assert all(not (issue["issue"] == "missing_support" and issue["node_id"] == "slab-1") for issue in structural["issues"])
+ assert any(issue["issue"] == "unsupported_support_target" and issue["target_id"] == "beam-1" for issue in structural["issues"])
+ assert any(issue["issue"] == "support_flag_conflict" and issue["node_id"] == "beam-1" for issue in structural["issues"])
+
+
+async def test_graph_invalid_data_and_atomic_compile():
+ provider = SemanticGraphProvider()
+ baseline = sample_graph_payload()
+ await provider.execute_tool("graph_compile", baseline)
+ before_health = await provider.check_health()
+ before_query = await provider.execute_tool(
+ "graph_query_relations",
+ {"node_id": "wall-1", "direction": "outgoing", "limit": 10},
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": baseline["nodes"],
+ "edges": [
+ {"source": "wall-1", "target": "missing-node", "relation": "CONNECTED_TO"}
+ ],
+ },
+ )
+
+ after_health = await provider.check_health()
+ after_query = await provider.execute_tool(
+ "graph_query_relations",
+ {"node_id": "wall-1", "direction": "outgoing", "limit": 10},
+ )
+ assert after_health == before_health
+ assert after_query == before_query
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_add_relation",
+ {
+ "source_id": "wall-1",
+ "target_id": "wall-2",
+ "relation": "INVALID_RELATION",
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": [{"id": "", "type": "Wall"}],
+ "edges": [],
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": [{"id": 1.5, "type": "Wall"}],
+ "edges": [],
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": [{"id": {"value": "bad"}, "type": "Wall"}],
+ "edges": [],
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": [{"id": "bad-aabb", "aabb": {"min": [1, 0, 0], "max": [0, 1, 1]}}],
+ "edges": [],
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": {},
+ "edges": [],
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_compile",
+ {
+ "nodes": [],
+ "edges": {},
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_audit_clashes",
+ {
+ "nodes": {},
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_audit_disconnected",
+ {
+ "node_ids": "wall-1",
+ },
+ )
+
+ with pytest.raises(ValueError):
+ await provider.execute_tool(
+ "graph_audit_structural_loads",
+ {
+ "node_types": "Wall",
+ },
+ )
diff --git a/packages/mcp-server-revit/tests/test_identity_mapper.py b/packages/mcp-server-revit/tests/test_identity_mapper.py
new file mode 100644
index 0000000..41238e4
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_identity_mapper.py
@@ -0,0 +1,104 @@
+import pytest
+from pathlib import Path
+from revit_mcp_server.providers.identity_mapper import AECMapperProvider
+from revit_mcp_server.security.workspace import WorkspaceMonitor
+
+
+async def test_deterministic_guid_translation(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = AECMapperProvider(workspace=workspace)
+
+ # Revit UniqueId (with instance suffix) to IFC GlobalId
+ revit_id = "2b6b2b73-09be-48dc-b6c8-52d3c368d0a8-0002ab1f"
+ res1 = await provider.execute_tool("aec_translate_id", {
+ "source_id": revit_id,
+ "source_format": "revit_unique_id",
+ "target_format": "ifc_guid"
+ })
+ assert res1["translated_id"] == "0hQojp2Rv8tBR8KjF3QD2e"
+ assert res1["source"] == "deterministic_guid_compression"
+
+ # IFC GlobalId to Revit GUID
+ ifc_id = "0hQojp2Rv8tBR8KjF3QD2e"
+ res2 = await provider.execute_tool("aec_translate_id", {
+ "source_id": ifc_id,
+ "source_format": "ifc_guid",
+ "target_format": "revit_unique_id"
+ })
+ assert res2["translated_id"] == "2b6b2b73-09be-48dc-b6c8-52d3c368d0a8"
+ assert res2["source"] == "deterministic_ifc_expansion"
+
+
+async def test_custom_registered_mapping(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = AECMapperProvider(workspace=workspace)
+
+ # Register custom mappings
+ reg = await provider.execute_tool("aec_register_mapping", {
+ "mappings": [
+ {
+ "revit_unique_id": "my-revit-element-id-123-abc",
+ "rhino_uuid": "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"
+ }
+ ]
+ })
+ assert reg["status"] == "success"
+ assert reg["count_registered"] == 1
+
+ # Translate using registered mappings
+ res = await provider.execute_tool("aec_translate_id", {
+ "source_id": "my-revit-element-id-123-abc",
+ "source_format": "revit_unique_id",
+ "target_format": "rhino_uuid"
+ })
+ assert res["translated_id"] == "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"
+ assert res["source"] == "custom_registry"
+
+
+async def test_workspace_path_mapping(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = AECMapperProvider(workspace=workspace)
+
+ test_file = tmp_path / "subdir" / "project.rvt"
+ test_file.parent.mkdir(exist_ok=True)
+ test_file.touch()
+
+ # Relative format
+ rel_res = await provider.execute_tool("aec_map_workspace_path", {
+ "path": str(test_file),
+ "target_format": "relative"
+ })
+ assert rel_res["mapped_path"] == "subdir/project.rvt"
+
+ # Windows Absolute format
+ win_res = await provider.execute_tool("aec_map_workspace_path", {
+ "path": str(test_file),
+ "target_format": "absolute_windows"
+ })
+ assert "\\" in win_res["mapped_path"]
+
+ # POSIX Absolute format
+ posix_res = await provider.execute_tool("aec_map_workspace_path", {
+ "path": str(test_file),
+ "target_format": "absolute_posix"
+ })
+ assert "/" in posix_res["mapped_path"]
+ assert ":" not in posix_res["mapped_path"]
+
+
+async def test_path_mapping_traversal_protection(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = AECMapperProvider(workspace=workspace)
+
+ outside_file = tmp_path.parent / "unauthorized.txt"
+
+ with pytest.raises(Exception) as exc:
+ await provider.execute_tool("aec_map_workspace_path", {
+ "path": str(outside_file),
+ "target_format": "relative"
+ })
+ assert "outside the allowed workspace" in str(exc.value).lower()
diff --git a/packages/mcp-server-revit/tests/test_jobs.py b/packages/mcp-server-revit/tests/test_jobs.py
new file mode 100644
index 0000000..5c89270
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_jobs.py
@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+import time
+
+import pytest
+
+from revit_mcp_server.jobs import JobManager
+
+
+async def wait_for_status(job_manager: JobManager, job_id: str, statuses: set[str], timeout: float = 1.5):
+ loop = asyncio.get_running_loop()
+ deadline = loop.time() + timeout
+ while True:
+ snapshot = await job_manager.get(job_id)
+ assert snapshot is not None
+ if snapshot.status in statuses:
+ return snapshot
+ if loop.time() >= deadline:
+ raise AssertionError(f"Timed out waiting for {statuses}, last status was {snapshot.status}")
+ await asyncio.sleep(0.01)
+
+
+def test_submit_returns_immediately_for_sync_jobs_and_completes():
+ async def main():
+ manager = JobManager()
+ started = threading.Event()
+ release = threading.Event()
+
+ def job():
+ started.set()
+ release.wait(1)
+ return {"output_path": r"C:\Users\sammo\OneDrive\Documenten\GitHub\Autodesk-Revit-MCP-Server\out.rvt", "count": 3}
+
+ reference = await manager.submit(job)
+ assert reference.status in {"queued", "running"}
+
+ await asyncio.wait_for(asyncio.to_thread(started.wait, 1), 0.5)
+ current = await manager.get(reference.job_id)
+ assert current is not None
+ assert current.status in {"queued", "running"}
+
+ release.set()
+ finished = await wait_for_status(manager, reference.job_id, {"completed"})
+ assert finished.result == {"output_path": "<path>", "count": 3}
+
+ asyncio.run(main())
+
+
+def test_active_capacity_blocks_new_non_idempotent_jobs_but_allows_retries():
+ async def main():
+ manager = JobManager(max_active_jobs=1)
+ gate = asyncio.Event()
+
+ async def job():
+ await gate.wait()
+ return {"done": True}
+
+ first = await manager.submit(job, idempotency_key="revit:capacity-1")
+ retry = await manager.submit(job, idempotency_key="revit:capacity-1")
+ assert retry.job_id == first.job_id
+
+ with pytest.raises(RuntimeError, match="active job capacity"):
+ await manager.submit(job)
+
+ gate.set()
+ finished = await wait_for_status(manager, first.job_id, {"completed"})
+ assert finished.result == {"done": True}
+
+ asyncio.run(main())
+
+
+def test_async_completion_preserves_json_safe_result():
+ async def main():
+ manager = JobManager()
+
+ async def job():
+ await asyncio.sleep(0.02)
+ return {"ok": True, "items": [1, 2, 3]}
+
+ reference = await manager.submit(job)
+ finished = await wait_for_status(manager, reference.job_id, {"completed"})
+ assert finished.result == {"ok": True, "items": [1, 2, 3]}
+ assert finished.error is None
+
+ asyncio.run(main())
+
+
+def test_artifacts_are_bounded_per_job():
+ async def main():
+ manager = JobManager(max_artifacts_per_job=2)
+
+ async def job(context):
+ await context.update_progress(artifact={"name": "one"})
+ await context.update_progress(artifact={"name": "two"})
+ await context.update_progress(artifact={"name": "three"})
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ finished = await wait_for_status(manager, reference.job_id, {"completed"})
+ assert [artifact["name"] for artifact in finished.artifacts] == ["two", "three"]
+ assert len(finished.artifacts) == 2
+
+ asyncio.run(main())
+
+
+def test_failure_redacts_secret_and_path_details():
+ async def main():
+ manager = JobManager()
+ secret = "super-secret-token"
+ leaked_path = r"C:\Users\sammo\OneDrive\Documenten\GitHub\Autodesk-Revit-MCP-Server\private\vault.rvt"
+
+ async def job():
+ raise RuntimeError(f"failed for {leaked_path} token={secret}")
+
+ reference = await manager.submit(job)
+ failed = await wait_for_status(manager, reference.job_id, {"failed"})
+ assert failed.result is None
+ assert failed.error is not None
+ assert failed.error["type"] == "RuntimeError"
+ error_text = failed.error["message"]
+ assert secret not in error_text
+ assert leaked_path not in error_text
+ assert "Traceback" not in error_text
+
+ asyncio.run(main())
+
+
+def test_non_finite_progress_is_rejected():
+ async def main():
+ manager = JobManager()
+
+ async def job(context):
+ with pytest.raises(ValueError, match="progress must be finite"):
+ await context.update_progress(progress=float("nan"))
+ with pytest.raises(ValueError, match="progress must be finite"):
+ await context.update_progress(progress=float("inf"))
+ await context.update_progress(progress=42.0, message="recover")
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ finished = await wait_for_status(manager, reference.job_id, {"completed"})
+ assert finished.progress == 42.0
+ assert finished.message == "recover"
+ assert finished.result == {"ok": True}
+
+ asyncio.run(main())
+
+
+def test_cancellation_marks_job_cancelled():
+ async def main():
+ manager = JobManager()
+ started = asyncio.Event()
+ release = asyncio.Event()
+
+ async def job(context):
+ await context.update_progress(progress=10, message="running")
+ started.set()
+ await release.wait()
+ return {"should_not": "complete"}
+
+ reference = await manager.submit(job)
+ await asyncio.wait_for(started.wait(), 0.5)
+ cancelled = await manager.cancel(reference.job_id)
+ assert cancelled is not None
+ assert cancelled.status == "cancelled"
+ release.set()
+ snapshot = await wait_for_status(manager, reference.job_id, {"cancelled"})
+ assert snapshot.result is None
+ assert snapshot.error is None
+
+ asyncio.run(main())
+
+
+def test_shutdown_can_cancel_running_jobs():
+ async def main():
+ manager = JobManager()
+ started = asyncio.Event()
+
+ async def job():
+ started.set()
+ await asyncio.sleep(10)
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ await asyncio.wait_for(started.wait(), 0.5)
+ await manager.shutdown(cancel_running=True)
+
+ snapshot = await manager.get(reference.job_id)
+ assert snapshot is not None
+ assert snapshot.status == "cancelled"
+ assert snapshot.result is None
+ assert snapshot.error is None
+
+ with pytest.raises(RuntimeError):
+ await manager.submit(job)
+
+ asyncio.run(main())
+
+
+def test_idempotency_reuses_active_and_completed_jobs():
+ async def main():
+ manager = JobManager()
+ gate = asyncio.Event()
+
+ async def job():
+ await gate.wait()
+ return {"done": True}
+
+ first = await manager.submit(job, idempotency_key="revit:op-1")
+ second = await manager.submit(job, idempotency_key="revit:op-1")
+ assert second.job_id == first.job_id
+
+ gate.set()
+ finished = await wait_for_status(manager, first.job_id, {"completed"})
+ third = await manager.submit(job, idempotency_key="revit:op-1")
+ assert third.job_id == first.job_id
+ assert third.status == "completed"
+ assert third.result == {"done": True}
+ assert finished.result == {"done": True}
+
+ asyncio.run(main())
+
+
+def test_manager_is_bound_to_first_event_loop():
+ manager = JobManager()
+ job_id_holder: dict[str, str] = {}
+
+ async def first_loop():
+ async def job():
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ job_id_holder["job_id"] = reference.job_id
+ await wait_for_status(manager, reference.job_id, {"completed"})
+
+ asyncio.run(first_loop())
+
+ async def second_loop():
+ with pytest.raises(RuntimeError, match="different event loop"):
+ await manager.get(job_id_holder["job_id"])
+
+ asyncio.run(second_loop())
+
+
+def test_progress_updates_are_visible_while_running():
+ async def main():
+ manager = JobManager()
+ first_update = asyncio.Event()
+ finish = asyncio.Event()
+
+ async def job(context):
+ await context.update_progress(progress=15, message="phase 1")
+ first_update.set()
+ await finish.wait()
+ await context.update_progress(
+ progress=100,
+ message="phase 2",
+ artifact={"name": "model", "path": r"C:\Users\sammo\OneDrive\Documenten\GitHub\Autodesk-Revit-MCP-Server\exports\model.ifc"},
+ )
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ await asyncio.wait_for(first_update.wait(), 0.5)
+ snapshot = await manager.get(reference.job_id)
+ assert snapshot is not None
+ assert snapshot.status == "running"
+ assert snapshot.progress == 15
+ assert snapshot.message == "phase 1"
+
+ finish.set()
+ done = await wait_for_status(manager, reference.job_id, {"completed"})
+ assert done.progress == 100
+ assert done.message == "phase 2"
+ assert done.artifacts
+ assert done.artifacts[0]["name"] == "model"
+ assert "<path>" in done.artifacts[0]["path"]
+
+ asyncio.run(main())
+
+
+def test_retention_prunes_old_terminal_jobs():
+ async def main():
+ manager = JobManager(max_retained_jobs=1, retention_ttl_seconds=60.0)
+
+ async def job(value: int):
+ return {"value": value}
+
+ first = await manager.submit(job, 1)
+ await wait_for_status(manager, first.job_id, {"completed"})
+ second = await manager.submit(job, 2)
+ await wait_for_status(manager, second.job_id, {"completed"})
+
+ assert await manager.get(first.job_id) is None
+ retained = await manager.get(second.job_id)
+ assert retained is not None
+ assert retained.result == {"value": 2}
+
+ asyncio.run(main())
+
+
+def test_shutdown_waits_for_running_jobs_and_rejects_new_submissions():
+ async def main():
+ manager = JobManager()
+ finished = asyncio.Event()
+
+ async def job():
+ await asyncio.sleep(0.02)
+ finished.set()
+ return {"ok": True}
+
+ reference = await manager.submit(job)
+ await manager.shutdown()
+ assert finished.is_set()
+
+ snapshot = await manager.get(reference.job_id)
+ assert snapshot is not None
+ assert snapshot.status == "completed"
+ assert snapshot.result == {"ok": True}
+
+ with pytest.raises(RuntimeError):
+ await manager.submit(job)
+
+ asyncio.run(main())
diff --git a/packages/mcp-server-revit/tests/test_providers.py b/packages/mcp-server-revit/tests/test_providers.py
new file mode 100644
index 0000000..6904ebb
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_providers.py
@@ -0,0 +1,151 @@
+import os
+import pytest
+from pathlib import Path
+from typing import Dict, Any
+
+import ifcopenshell
+from revit_mcp_server.config import BridgeMode, Config
+from revit_mcp_server.providers import ProviderRegistry, RevitProvider, IfcProvider, FakeProvider
+from revit_mcp_server.security.workspace import WorkspaceMonitor
+
+
+def create_sample_ifc(path: Path):
+ """Programmatically generate a minimal valid IFC2X3 file for testing."""
+ file = ifcopenshell.file(schema="IFC2X3")
+
+ project = file.create_entity("IfcProject", GlobalId="0000000000000000000001", Name="Test Project")
+ site = file.create_entity(
+ "IfcSite",
+ GlobalId="0000000000000000000002",
+ Name="Test Site",
+ RefLatitude=(52, 30, 0, 0),
+ RefLongitude=(4, 45, 0, 0),
+ RefElevation=10.0
+ )
+ building = file.create_entity("IfcBuilding", GlobalId="0000000000000000000003", Name="Test Building")
+ storey = file.create_entity("IfcBuildingStorey", GlobalId="0000000000000000000004", Name="Test Storey")
+
+ file.create_entity("IfcRelAggregates", GlobalId="0000000000000000000005", RelatingObject=project, RelatedObjects=[site])
+ file.create_entity("IfcRelAggregates", GlobalId="0000000000000000000006", RelatingObject=site, RelatedObjects=[building])
+ file.create_entity("IfcRelAggregates", GlobalId="0000000000000000000007", RelatingObject=building, RelatedObjects=[storey])
+
+ # Create a wall
+ wall = file.create_entity("IfcWall", GlobalId="0x1234567890abcdef123456", Name="Sample Wall")
+ file.create_entity("IfcRelContainedInSpatialStructure", GlobalId="0000000000000000000008", RelatingStructure=storey, RelatedElements=[wall])
+
+ # Add some properties to the wall
+ pset = file.create_entity("IfcPropertySet", GlobalId="0000000000000000000009", Name="Pset_WallCommon")
+ prop = file.create_entity("IfcPropertySingleValue", Name="LoadBearing", NominalValue=file.create_entity("IfcBoolean", True))
+ pset.HasProperties = [prop]
+ file.create_entity("IfcRelDefinesByProperties", GlobalId="0000000000000000000010", RelatedObjects=[wall], RelatingPropertyDefinition=pset)
+
+ file.write(str(path))
+
+
+def test_provider_registry():
+ registry = ProviderRegistry()
+ fake = FakeProvider()
+ registry.register(fake)
+
+ assert registry.get_provider("fake") is fake
+ assert len(registry.get_all_providers()) == 1
+ assert len(registry.get_all_tools()) == 1
+ assert registry.get_all_tools()[0].name == "fake_tool"
+
+ provider = registry.lookup_tool_provider("fake_tool")
+ assert provider is fake
+
+
+async def test_revit_provider_mock_mode(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = RevitProvider(workspace=workspace, mode=BridgeMode.mock)
+
+ health = await provider.check_health()
+ assert health["status"] == "healthy"
+
+ capabilities = provider.get_capabilities()
+ assert len(capabilities) >= 100
+
+ # Verify execution of legacy dot notation
+ res1 = await provider.execute_tool("revit.health", {"request_id": "test-1"})
+ assert res1["status"] == "healthy"
+
+ # Verify execution of underscore notation
+ res2 = await provider.execute_tool("revit_health", {"request_id": "test-2"})
+ assert res2["status"] == "healthy"
+
+
+async def test_ifc_provider_tools(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = IfcProvider(workspace=workspace)
+
+ # Generate fixture file
+ ifc_file_path = tmp_path / "model.ifc"
+ create_sample_ifc(ifc_file_path)
+
+ # Health
+ health = await provider.execute_tool("ifc_health", {})
+ assert health["status"] == "healthy"
+
+ # Metadata
+ meta = await provider.execute_tool("ifc_get_metadata", {"ifc_path": str(ifc_file_path)})
+ assert meta["schema"] == "IFC2X3"
+ assert meta["project_name"] == "Test Project"
+ assert "georeferencing" in meta
+ assert meta["georeferencing"]["latitude"] is not None
+
+ # Spatial structure
+ spatial = await provider.execute_tool("ifc_get_spatial_structure", {"ifc_path": str(ifc_file_path)})
+ struct = spatial["spatial_structure"]
+ assert struct["name"] == "Test Project"
+ assert len(struct["children"]) == 1 # Site
+ assert struct["children"][0]["name"] == "Test Site"
+
+ # Query elements
+ query = await provider.execute_tool("ifc_query_elements", {
+ "ifc_path": str(ifc_file_path),
+ "ifc_class": "IfcWall"
+ })
+ elements = query["elements"]
+ assert len(elements) == 1
+ assert elements[0]["name"] == "Sample Wall"
+ assert elements[0]["guid"] == "0x1234567890abcdef123456"
+
+ # Properties
+ props = await provider.execute_tool("ifc_get_properties", {
+ "ifc_path": str(ifc_file_path),
+ "element_id": "0x1234567890abcdef123456"
+ })
+ assert "property_sets" in props
+ assert "Pset_WallCommon" in props["property_sets"]
+ assert props["property_sets"]["Pset_WallCommon"]["LoadBearing"] is True
+
+ # Bounding Box
+ bbox = await provider.execute_tool("ifc_get_bounding_box", {
+ "ifc_path": str(ifc_file_path),
+ "element_id": "0x1234567890abcdef123456"
+ })
+ assert "element" in bbox
+
+ # Validation
+ val = await provider.execute_tool("ifc_validate", {"ifc_path": str(ifc_file_path)})
+ assert "is_valid" in val
+
+
+async def test_ifc_provider_path_traversal_protection(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = IfcProvider(workspace=workspace)
+
+ # File outside workspace
+ outside_dir = tmp_path.parent / "outside"
+ outside_dir.mkdir(exist_ok=True)
+ outside_file = outside_dir / "unauthorized.ifc"
+
+ with pytest.raises(Exception) as exc:
+ await provider.execute_tool("ifc_get_metadata", {"ifc_path": str(outside_file)})
+
+ # Pydantic or WorkspaceMonitor raises ValueError or related custom errors for paths outside workspace
+ assert "outside the allowed workspace" in str(exc.value).lower()
diff --git a/packages/mcp-server-revit/tests/test_rhino_provider.py b/packages/mcp-server-revit/tests/test_rhino_provider.py
new file mode 100644
index 0000000..95eff48
--- /dev/null
+++ b/packages/mcp-server-revit/tests/test_rhino_provider.py
@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import base64
+import json
+
+import httpx
+import pytest
+
+from revit_mcp_server.providers.rhino import RhinoProvider
+from revit_mcp_server.security.workspace import WorkspaceMonitor
+
+
+def _write_sample_file(path, content=b"sample"):
+ path.write_bytes(content)
+ return path
+
+
+def test_rhino_capabilities_are_present(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example")
+
+ names = [tool.name for tool in provider.get_capabilities()]
+ assert names == [
+ "rhino_health",
+ "rhino_get_definition_io",
+ "rhino_evaluate_definition",
+ "rhino_query_file_geometry",
+ "rhino_get_layers",
+ "rhino_get_geometry_details",
+ ]
+
+ schema_dump = json.dumps([tool.model_dump(by_alias=True) for tool in provider.get_capabilities()])
+ assert "RHINO_COMPUTE_KEY" not in schema_dump
+ assert "MCP_RHINO_COMPUTE_KEY" not in schema_dump
+
+
+async def test_rhino_health_uses_injected_client_and_official_header(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ seen = {}
+ secret = "super-secret-token"
+
+ async def handler(request: httpx.Request) -> httpx.Response:
+ seen["method"] = request.method
+ seen["path"] = request.url.path
+ seen["auth"] = request.headers.get("RhinoComputeKey")
+ return httpx.Response(200, json={"status": "healthy", "service": "rhino"})
+
+ client = httpx.AsyncClient(transport=httpx.MockTransport(handler), base_url="https://compute.example")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example", api_key=secret, client=client)
+
+ response = await provider.check_health()
+ assert response["status"] == "healthy"
+ assert seen == {"method": "GET", "path": "/health", "auth": secret}
+
+ await provider.shutdown()
+ await client.aclose()
+
+
+async def test_rhino_get_definition_io_validates_workspace_and_payload(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ definition_path = _write_sample_file(tmp_path / "function.gh", b"gh-bytes")
+ seen = {}
+
+ async def handler(request: httpx.Request) -> httpx.Response:
+ seen["path"] = request.url.path
+ seen["auth"] = request.headers.get("RhinoComputeKey")
+ seen["has_x_api_key"] = "X-Api-Key" in request.headers
+ seen["payload"] = json.loads(request.content.decode("utf-8"))
+ return httpx.Response(200, json={"definition_id": "def-123", "inputs": [], "outputs": []})
+
+ client = httpx.AsyncClient(transport=httpx.MockTransport(handler), base_url="https://compute.example")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example", api_key="secret", client=client)
+
+ response = await provider.execute_tool("rhino_get_definition_io", {"definition_path": str(definition_path)})
+ assert response["definition_id"] == "def-123"
+ assert seen["path"] == "/grasshopper/io"
+ assert seen["auth"] == "secret"
+ assert seen["has_x_api_key"] is False
+ assert seen["payload"]["file_name"] == "function.gh"
+ assert seen["payload"]["file_data"] == base64.b64encode(b"gh-bytes").decode("ascii")
+ assert set(seen["payload"]) == {"file_name", "file_data"}
+
+ await provider.shutdown()
+ await client.aclose()
+
+
+async def test_rhino_evaluate_definition_posts_io_then_solve(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ definition_path = _write_sample_file(tmp_path / "function.ghx", b"ghx-bytes")
+ requests = []
+
+ async def handler(request: httpx.Request) -> httpx.Response:
+ requests.append((request.method, request.url.path, json.loads(request.content.decode("utf-8"))))
+ if request.url.path.endswith("/io"):
+ return httpx.Response(200, json={"id": "definition-777"})
+ return httpx.Response(200, json={"values": [{"ParamName": "A", "InnerTree": {}}], "errors": [], "warnings": []})
+
+ client = httpx.AsyncClient(transport=httpx.MockTransport(handler), base_url="https://compute.example")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example", client=client)
+
+ result = await provider.execute_tool(
+ "rhino_evaluate_definition",
+ {
+ "definition_path": str(definition_path),
+ "input_trees": [
+ {"ParamName": "X", "InnerTree": {"{0}": [{"type": "System.Double", "data": "1.0"}]}}
+ ],
+ },
+ )
+
+ assert result["values"][0]["ParamName"] == "A"
+ assert [item[1] for item in requests] == ["/grasshopper/io", "/grasshopper/solve"]
+ assert requests[1][2]["definition_id"] == "definition-777"
+ assert requests[1][2]["input_trees"][0]["ParamName"] == "X"
+ assert "definition_path" not in requests[1][2]
+
+ await provider.shutdown()
+ await client.aclose()
+
+
+ "tool_name,filename,expected_path",
+ [
+ ("rhino_query_file_geometry", "model.3dm", "/rhino/query_file_geometry"),
+ ("rhino_get_layers", "model.3dm", "/rhino/layers"),
+ ("rhino_get_geometry_details", "model.3dm", "/rhino/geometry_details"),
+ ],
+)
+async def test_rhino_3dm_tools_validate_extensions_and_use_expected_paths(tmp_path, tool_name, filename, expected_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ file_path = _write_sample_file(tmp_path / filename, b"3dm-bytes")
+ seen = {}
+
+ async def handler(request: httpx.Request) -> httpx.Response:
+ seen["path"] = request.url.path
+ seen["auth"] = request.headers.get("RhinoComputeKey")
+ seen["payload"] = json.loads(request.content.decode("utf-8"))
+ return httpx.Response(200, json={"status": "ok", "tool": tool_name})
+
+ client = httpx.AsyncClient(transport=httpx.MockTransport(handler), base_url="https://compute.example")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example", client=client)
+
+ result = await provider.execute_tool(tool_name, {"file_path": str(file_path), "include_hidden": True, "object_ids": [1, 2]})
+ assert result["tool"] == tool_name
+ assert seen["path"] == expected_path
+ assert seen["auth"] is None
+ assert seen["payload"]["file_name"] == "model.3dm"
+ assert "file_path" not in seen["payload"]
+ assert set(seen["payload"]).issuperset({"file_name", "file_data"})
+
+ await provider.shutdown()
+ await client.aclose()
+
+
+async def test_rhino_rejects_unsupported_extensions_before_request(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ file_path = _write_sample_file(tmp_path / "unsupported.txt")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example")
+
+ with pytest.raises(ValueError, match="Unsupported Rhino file extension"):
+ await provider.execute_tool("rhino_get_definition_io", {"definition_path": str(file_path)})
+
+ await provider.shutdown()
+
+
+async def test_rhino_redacts_secret_from_error_messages(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ async def handler(request: httpx.Request) -> httpx.Response:
+ return httpx.Response(500, json={"error": "boom"})
+
+ client = httpx.AsyncClient(transport=httpx.MockTransport(handler), base_url="https://compute.example")
+ provider = RhinoProvider(
+ workspace=workspace,
+ base_url="https://compute.example",
+ api_key="top-secret-token",
+ client=client,
+ )
+
+ with pytest.raises(Exception) as exc:
+ await provider.check_health()
+
+ assert "top-secret-token" not in str(exc.value)
+ assert "RhinoComputeKey" not in str(exc.value)
+
+ await provider.shutdown()
+ await client.aclose()
+
+
+def test_rhino_rejects_non_loopback_http_base_url(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+
+ with pytest.raises(ValueError, match="must use https unless the host is localhost or 127.0.0.1"):
+ RhinoProvider(workspace=workspace, base_url="http://compute.example")
+
+
+def test_rhino_allows_localhost_http_base_url(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ provider = RhinoProvider(workspace=workspace, base_url="http://127.0.0.1:5001")
+ assert provider.base_url == "http://127.0.0.1:5001"
+
+
+async def test_rhino_rejects_oversized_uploads_before_read(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ definition_path = _write_sample_file(tmp_path / "huge.gh", b"x" * 16)
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example", max_upload_bytes=8)
+
+ with pytest.raises(ValueError, match="exceeds the maximum upload size"):
+ await provider.execute_tool("rhino_get_definition_io", {"definition_path": str(definition_path)})
+
+ await provider.shutdown()
+
+
+async def test_rhino_workspace_errors_do_not_expose_absolute_paths(tmp_path):
+ workspace = WorkspaceMonitor([tmp_path])
+ outside_dir = tmp_path.parent / "outside"
+ outside_dir.mkdir(exist_ok=True)
+ file_path = _write_sample_file(outside_dir / "escape.gh")
+ provider = RhinoProvider(workspace=workspace, base_url="https://compute.example")
+
+ with pytest.raises(ValueError, match="outside the allowed workspace"):
+ await provider.execute_tool("rhino_get_definition_io", {"definition_path": str(file_path)})
+
+ await provider.shutdown()
diff --git a/packages/mcp-server-revit/tests/test_server.py b/packages/mcp-server-revit/tests/test_server.py
index 7964e34..041fe6a 100644
--- a/packages/mcp-server-revit/tests/test_server.py
+++ b/packages/mcp-server-revit/tests/test_server.py
@@ -34,6 +34,101 @@ def test_handle_tool_bridge_mode(tmp_path: Path):
cfg = create_config(tmp_path, bridge_url="http://bridge", mode=BridgeMode.bridge)
bridge = DummyBridge(cfg.bridge_url)
server = MCPServer(config=cfg, bridge_factory=lambda _: bridge)
- response = server.handle_tool("revit.health", {"request_id": "req-bridge"})
- assert response["echo"] == "revit.health"
- assert bridge.calls
+ try:
+ response = server.handle_tool("revit.health", {"request_id": "req-bridge"})
+ assert response["echo"] == "revit.health"
+ assert bridge.calls
+ finally:
+ server.shutdown()
+
+
+def test_deferred_execution_and_job_tools(tmp_path: Path):
+ cfg = create_config(tmp_path)
+ server = MCPServer(config=cfg)
+ try:
+ # Trigger a tool call asynchronously (e.g. revit.health)
+ response = server.handle_tool("revit.health", {"request_id": "req-async", "run_async": True})
+ assert response["status"] in ("queued", "running")
+ job_id = response["job_id"]
+ assert job_id
+
+ # Wait for the job to complete
+ import time
+ for _ in range(100):
+ status_resp = server.handle_tool("job_status", {"job_id": job_id})
+ if status_resp["status"] == "completed":
+ break
+ time.sleep(0.01)
+ else:
+ status_resp = server.handle_tool("job_status", {"job_id": job_id})
+ assert status_resp["status"] == "completed"
+
+ assert status_resp["result"]["status"] == "healthy"
+
+ # Test cancel a completed/running job
+ cancel_resp = server.handle_tool("job_cancel", {"job_id": job_id})
+ assert cancel_resp["job_id"] == job_id
+ finally:
+ server.shutdown()
+
+
+def test_redaction_in_server(tmp_path: Path):
+ cfg = create_config(tmp_path)
+ server = MCPServer(config=cfg)
+ try:
+ # Register mapping with paths and secrets
+ register_resp = server.handle_tool(
+ "aec_register_mapping",
+ {
+ "mappings": [
+ {
+ "revit_unique_id": "revit-id",
+ "ifc_guid": "ifc-id",
+ "rhino_uuid": "rhino-id",
+ "token": "sensitive-token-123",
+ "file_path": r"C:\Users\sammo\secret.rvt",
+ }
+ ]
+ }
+ )
+ assert register_resp["status"] == "success"
+
+ # Query translation mapping
+ response = server.handle_tool(
+ "aec_translate_id",
+ {
+ "source_id": "revit-id",
+ "source_format": "revit_unique_id",
+ "target_format": "ifc_guid"
+ }
+ )
+ assert response["translated_id"] == "ifc-id"
+
+ # Verify path mapping output redaction
+ dummy_file = tmp_path / "test.rvt"
+ dummy_file.write_text("dummy")
+ path_resp = server.handle_tool(
+ "aec_map_workspace_path",
+ {
+ "path": str(dummy_file),
+ "target_format": "absolute_windows"
+ }
+ )
+ assert "test.rvt" not in path_resp["mapped_path"]
+ assert "<redacted-path>" in path_resp["mapped_path"]
+
+ # Trigger tool call with path input to check path sanitization in errors
+ non_existent_file = tmp_path / "secret.ifc"
+ response_err = server.handle_tool(
+ "ifc_validate",
+ {"ifc_path": str(non_existent_file)}
+ )
+ assert response_err["status"] == "error"
+ err_msg = response_err["message"]
+ assert "secret.ifc" not in err_msg
+ assert "C:\\" not in err_msg
+ assert "<redacted-path>" in err_msg
+ finally:
+ server.shutdown()
+
+
diff --git a/packages/mcp-server-revit/uv.lock b/packages/mcp-server-revit/uv.lock
index c0d0b2a..c70821d 100644
--- a/packages/mcp-server-revit/uv.lock
+++ b/packages/mcp-server-revit/uv.lock
@@ -12,7 +12,9 @@ version = "1.1.0"
source = { editable = "." }
dependencies = [
{ name = "httpx" },
+ { name = "ifcopenshell" },
{ name = "mcp" },
+ { name = "networkx" },
{ name = "pydantic" },
{ name = "pydantic-settings" },
{ name = "python-dotenv" },
@@ -28,8 +30,10 @@ dev = [
[package.metadata]
requires-dist = [
{ name = "httpx", specifier = ">=0.24" },
+ { name = "ifcopenshell", specifier = ">=0.7.0" },
{ name = "mcp", specifier = ">=0.9.0" },
{ name = "mypy", marker = "extra == 'dev'", specifier = ">=1.8" },
+ { name = "networkx", specifier = ">=3.0" },
{ name = "pydantic", specifier = ">=2.5" },
{ name = "pydantic-settings", specifier = ">=1.3" },
{ name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
@@ -323,6 +327,46 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
]
+[[package]]
+name = "ifcopenshell"
+version = "0.8.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "isodate" },
+ { name = "lark" },
+ { name = "numpy" },
+ { name = "python-dateutil" },
+ { name = "shapely" },
+ { name = "typing-extensions" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/59/37/bb8c2b208ca2821993216eb4dc8f41d2585bbe6256739ea32d05b1ff654c/ifcopenshell-0.8.5-py310-none-macosx_10_15_x86_64.whl", hash = "sha256:3b1c5a2ea655d96914ddafd258aa6183f29fb7a08b2b10a329b204b8deca7226", size = 44982843, upload-time = "2026-04-13T13:42:40.878Z" },
+ { url = "https://files.pythonhosted.org/packages/43/e1/03daf876c2496f21323a4a305c28c78b53ba7b6dceadc8ae4a59b7481432/ifcopenshell-0.8.5-py310-none-macosx_11_0_arm64.whl", hash = "sha256:beb9e761ea9b6678c5edff4d6ab31e40a771fffca3bc295810045de564f1b018", size = 42398229, upload-time = "2026-04-13T13:42:24.213Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/9e/8f2ec71a22d73d42feb400ff893fbcf28d5ac88787ae4ad09e0c5ec29bc1/ifcopenshell-0.8.5-py310-none-manylinux_2_31_aarch64.whl", hash = "sha256:8de53ba37e762f2e2ba7cf502f15504b886233f681c30245ae7b4ed82087445d", size = 41035477, upload-time = "2026-04-13T13:42:26.462Z" },
+ { url = "https://files.pythonhosted.org/packages/10/9d/ed885e74440cc145f56f661e128b66702cc880cba969a8444453b50ec202/ifcopenshell-0.8.5-py310-none-manylinux_2_31_x86_64.whl", hash = "sha256:487189a6a70f9c688ae58efa075312d0dbba3e83839abaafbfe669bbfdb66e2a", size = 43717796, upload-time = "2026-04-13T13:42:35.722Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/6a/877930c416402b5d381cd1c5e9f1edbf56cee13eca64b41d894f6aa512dc/ifcopenshell-0.8.5-py310-none-win_amd64.whl", hash = "sha256:86b60a3fba3c5b3c5a152a71b1a5038a78384fcaa0bab61297bf363c8bedd325", size = 24538316, upload-time = "2026-04-13T13:42:14.88Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/28/a0caaf40e59418b84c2838a25e317ff61a323135bdd344cf4cc948238cca/ifcopenshell-0.8.5-py311-none-macosx_10_15_x86_64.whl", hash = "sha256:ba916b73a1dd011abeee564b2bb0027c3dc679d77733d44f2f38009b70d413b5", size = 44982843, upload-time = "2026-04-13T13:43:22.436Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/05/9217aaa1639da7190da7290bc032704286abd64099f347eedf1e8e722e93/ifcopenshell-0.8.5-py311-none-macosx_11_0_arm64.whl", hash = "sha256:7dba9a0348600bd59ceb9222333e493b9b1c49fc69251a73bc707e77a445007d", size = 42398229, upload-time = "2026-04-13T13:42:36.627Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/19/557539d3e61786d6bc7b65bed170f36d5f7cc0cd4ec570aecd9425504152/ifcopenshell-0.8.5-py311-none-manylinux_2_31_aarch64.whl", hash = "sha256:e568a859b489ba43013795c3d682758d1ee905fe08919d2c96b5c5676167b243", size = 41035572, upload-time = "2026-04-13T13:42:36.877Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/d2/876d1f9564d06f8313b35c3c456241fba79d01a113655273cfb48303ff19/ifcopenshell-0.8.5-py311-none-manylinux_2_31_x86_64.whl", hash = "sha256:612e955ab0975bbc4134fe26c4c36d71a12525fd5c4b391573e6df3cd81713ec", size = 43717607, upload-time = "2026-04-13T13:42:53.312Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/7f/077d6ade67326a8e919edb7c8b240f5cc31506947198e8de4e73b5ca7b38/ifcopenshell-0.8.5-py311-none-win_amd64.whl", hash = "sha256:a994cb398aa822b0153ace11fc19deea108706d3a10339de9ac9dc13da21076d", size = 24539716, upload-time = "2026-04-13T13:42:11.211Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/e0/fd69ad4d872031960be6169526aa51c2a2f0360b9d19d57d5fcc48f40b24/ifcopenshell-0.8.5-py312-none-macosx_10_15_x86_64.whl", hash = "sha256:38f63e13cf326b195e2b9ac4ed45396cdda9b3ad29318ce04d7c4a401f7a3921", size = 44991884, upload-time = "2026-04-13T13:43:29.707Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/37/93b6738a88dd138d917eb177f2c6e5fc6fbf59b519151e8d90f462582ee1/ifcopenshell-0.8.5-py312-none-macosx_11_0_arm64.whl", hash = "sha256:89e60dbe8ea7014174ab332b6caad25465c446c118a896435f594ab24602a10a", size = 42400012, upload-time = "2026-04-13T13:43:16.854Z" },
+ { url = "https://files.pythonhosted.org/packages/45/17/b2bf757bf2112ae20f28866a94e70b5f5e4441deb7f306fbeca660deb643/ifcopenshell-0.8.5-py312-none-manylinux_2_31_aarch64.whl", hash = "sha256:a5183ae0431a9b87d89ca2e880dae986e4140f088293c3872a88ed3177e7308d", size = 41035338, upload-time = "2026-04-13T13:42:22.08Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/9f/3ae435c85e33f89e206b46965d02318d6b4276d89b39623dd1044c0a566f/ifcopenshell-0.8.5-py312-none-manylinux_2_31_x86_64.whl", hash = "sha256:dd154b121815e25bc4890f030bf2bdd8d99b059448e0d1205ac81388a3d321f4", size = 43718107, upload-time = "2026-04-13T13:43:15.989Z" },
+ { url = "https://files.pythonhosted.org/packages/97/ce/0464df6a6e6ebf71a9407337d257ac94f63eb1494800a88485e361b1640b/ifcopenshell-0.8.5-py312-none-win_amd64.whl", hash = "sha256:7927921dbfd18024f44780880c37e48460bbca7476da3b0c2607e044b31521d5", size = 24539561, upload-time = "2026-04-13T13:42:14.03Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/36/d2584ab891c7a5a6e0cd6c46d23460a042dc56cba2ccd3972b404fd070ba/ifcopenshell-0.8.5-py313-none-macosx_10_15_x86_64.whl", hash = "sha256:f8abac2bd3a3eb11009beb290834d8a5a2330d59a8600dede0faf7ddf8a8f16f", size = 44991886, upload-time = "2026-04-13T13:43:20.236Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/95/7318741d1441e22ce08492f4000694cb88edf1c76dfdd30d9f3815659fa5/ifcopenshell-0.8.5-py313-none-macosx_11_0_arm64.whl", hash = "sha256:9444ed9b924eaa76037653c56261098846bffa2f4732eefa8b83687163addecd", size = 42399997, upload-time = "2026-04-13T13:42:18.858Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/09/f3b4456d4e8751ef87bf2612571fdfcfbd3c51293c06df5e71ac1a7785a9/ifcopenshell-0.8.5-py313-none-manylinux_2_31_aarch64.whl", hash = "sha256:233e2afd81456ac278f2dd21360c509999498d0b8dc207230eb05e3063f87860", size = 41034024, upload-time = "2026-04-13T13:42:26.885Z" },
+ { url = "https://files.pythonhosted.org/packages/94/c8/2e6c88539020de9399298afec321c61d79929595877a7c4ed3bb24824d98/ifcopenshell-0.8.5-py313-none-manylinux_2_31_x86_64.whl", hash = "sha256:c03c47abbfd0afddcbc91b510d984d7c017a222877460da5e0a6496d89f185e4", size = 43718118, upload-time = "2026-04-13T13:42:37.221Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/7b/d9b8b7bdd5e398cf29f28c55361cbe85f8b8f94afcc26ce4b02ed2e6185c/ifcopenshell-0.8.5-py313-none-win_amd64.whl", hash = "sha256:6dd40d29b21d1c92104a4585a1ee6a31811305b68f5e3f7ee991f89f4d386366", size = 24538206, upload-time = "2026-04-13T13:42:12.213Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/23/bf3df66ccf86a3a50103e7ee305eee0f02a684f088cedf3afa195acca2ce/ifcopenshell-0.8.5-py314-none-macosx_10_15_x86_64.whl", hash = "sha256:f9e35e2df5397c795b320421192fcdb006573d1b36524f420d2474a4f9d842cf", size = 44987044, upload-time = "2026-04-13T13:42:24.375Z" },
+ { url = "https://files.pythonhosted.org/packages/35/8b/38f1a472b7c4657146125bc3eae8294289396a45cd1830cc0d88d5960506/ifcopenshell-0.8.5-py314-none-macosx_11_0_arm64.whl", hash = "sha256:8cf1f7fd49367aeba75eb56682f1454b2f353a979c6111a165bc05bc62148600", size = 42400429, upload-time = "2026-04-13T13:42:20.957Z" },
+ { url = "https://files.pythonhosted.org/packages/35/cb/05664ab9568b949687088d771ef9b1658a4c4cd135289553aa4d12cc93ee/ifcopenshell-0.8.5-py314-none-manylinux_2_31_aarch64.whl", hash = "sha256:005dced5aaa45064e73287c75ed9cf5f8ba54bce80c496fd76404313833cd62e", size = 41035596, upload-time = "2026-04-13T13:42:20.516Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/aa/6529f307901b03c49312a97ee9fa6aede996fb89094597a5b7743919e0f4/ifcopenshell-0.8.5-py314-none-manylinux_2_31_x86_64.whl", hash = "sha256:15b488347efce0d7f5ab5b6d5561cf30428353b6ee8c7c8a53724f4b10ad4ac6", size = 43717208, upload-time = "2026-04-13T13:42:50.056Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/32/333cfd39c468e2e365adba80e35cc551eb9c0f147cfe8497a64b0617919a/ifcopenshell-0.8.5-py314-none-win_amd64.whl", hash = "sha256:13a5992dc07e69c0c78df5479e1ff9635e6ce9fa70c841d9ce2931e8481eabb9", size = 24542242, upload-time = "2026-04-13T13:42:08.57Z" },
+]
+
[[package]]
name = "iniconfig"
version = "2.3.0"
@@ -332,6 +376,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
]
+[[package]]
+name = "isodate"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705, upload-time = "2024-10-08T23:04:11.5Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320, upload-time = "2024-10-08T23:04:09.501Z" },
+]
+
[[package]]
name = "jsonschema"
version = "4.26.0"
@@ -359,6 +412,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
]
+[[package]]
+name = "lark"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" },
+]
+
[[package]]
name = "librt"
version = "0.11.0"
@@ -517,6 +579,94 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
]
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
+ { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
+ { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
+ { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
+ { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
+ { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
+ { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
+ { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
+ { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
+ { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
+ { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
+ { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
+ { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
+ { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
+ { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
+ { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
+ { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
+ { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" },
+ { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" },
+ { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" },
+ { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" },
+ { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" },
+ { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" },
+ { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" },
+ { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" },
+ { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" },
+ { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" },
+ { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" },
+ { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
+ { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
+ { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
+]
+
[[package]]
name = "packaging"
version = "26.2"
@@ -723,6 +873,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
]
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
[[package]]
name = "python-dotenv"
version = "1.2.2"
@@ -939,6 +1101,74 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/15/19/016553f86f207450aebebc2b2b5088d086b901cc8186c02ac4284db3bd88/ruff-0.15.16-py3-none-win_arm64.whl", hash = "sha256:8cd61783afb39638a7133ef0d2dfb1e91277593962f81b5a8423eb0b888a6121", size = 11134555, upload-time = "2026-06-04T16:33:00.136Z" },
]
+[[package]]
+name = "shapely"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/bc/0989043118a27cccb4e906a46b7565ce36ca7b57f5a18b78f4f1b0f72d9d/shapely-2.1.2.tar.gz", hash = "sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9", size = 315489, upload-time = "2025-09-24T13:51:41.432Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8f/8d/1ff672dea9ec6a7b5d422eb6d095ed886e2e523733329f75fdcb14ee1149/shapely-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618", size = 1820038, upload-time = "2025-09-24T13:50:15.628Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/ce/28fab8c772ce5db23a0d86bf0adaee0c4c79d5ad1db766055fa3dab442e2/shapely-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d", size = 1626039, upload-time = "2025-09-24T13:50:16.881Z" },
+ { url = "https://files.pythonhosted.org/packages/70/8b/868b7e3f4982f5006e9395c1e12343c66a8155c0374fdc07c0e6a1ab547d/shapely-2.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09", size = 3001519, upload-time = "2025-09-24T13:50:18.606Z" },
+ { url = "https://files.pythonhosted.org/packages/13/02/58b0b8d9c17c93ab6340edd8b7308c0c5a5b81f94ce65705819b7416dba5/shapely-2.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26", size = 3110842, upload-time = "2025-09-24T13:50:21.77Z" },
+ { url = "https://files.pythonhosted.org/packages/af/61/8e389c97994d5f331dcffb25e2fa761aeedfb52b3ad9bcdd7b8671f4810a/shapely-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7", size = 4021316, upload-time = "2025-09-24T13:50:23.626Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/d4/9b2a9fe6039f9e42ccf2cb3e84f219fd8364b0c3b8e7bbc857b5fbe9c14c/shapely-2.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2", size = 4178586, upload-time = "2025-09-24T13:50:25.443Z" },
+ { url = "https://files.pythonhosted.org/packages/16/f6/9840f6963ed4decf76b08fd6d7fed14f8779fb7a62cb45c5617fa8ac6eab/shapely-2.1.2-cp311-cp311-win32.whl", hash = "sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6", size = 1543961, upload-time = "2025-09-24T13:50:26.968Z" },
+ { url = "https://files.pythonhosted.org/packages/38/1e/3f8ea46353c2a33c1669eb7327f9665103aa3a8dfe7f2e4ef714c210b2c2/shapely-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc", size = 1722856, upload-time = "2025-09-24T13:50:28.497Z" },
+ { url = "https://files.pythonhosted.org/packages/24/c0/f3b6453cf2dfa99adc0ba6675f9aaff9e526d2224cbd7ff9c1a879238693/shapely-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94", size = 1833550, upload-time = "2025-09-24T13:50:30.019Z" },
+ { url = "https://files.pythonhosted.org/packages/86/07/59dee0bc4b913b7ab59ab1086225baca5b8f19865e6101db9ebb7243e132/shapely-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359", size = 1643556, upload-time = "2025-09-24T13:50:32.291Z" },
+ { url = "https://files.pythonhosted.org/packages/26/29/a5397e75b435b9895cd53e165083faed5d12fd9626eadec15a83a2411f0f/shapely-2.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3", size = 2988308, upload-time = "2025-09-24T13:50:33.862Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/37/e781683abac55dde9771e086b790e554811a71ed0b2b8a1e789b7430dd44/shapely-2.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b", size = 3099844, upload-time = "2025-09-24T13:50:35.459Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/f3/9876b64d4a5a321b9dc482c92bb6f061f2fa42131cba643c699f39317cb9/shapely-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc", size = 3988842, upload-time = "2025-09-24T13:50:37.478Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/a0/704c7292f7014c7e74ec84eddb7b109e1fbae74a16deae9c1504b1d15565/shapely-2.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d", size = 4152714, upload-time = "2025-09-24T13:50:39.9Z" },
+ { url = "https://files.pythonhosted.org/packages/53/46/319c9dc788884ad0785242543cdffac0e6530e4d0deb6c4862bc4143dcf3/shapely-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454", size = 1542745, upload-time = "2025-09-24T13:50:41.414Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/bf/cb6c1c505cb31e818e900b9312d514f381fbfa5c4363edfce0fcc4f8c1a4/shapely-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179", size = 1722861, upload-time = "2025-09-24T13:50:43.35Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/90/98ef257c23c46425dc4d1d31005ad7c8d649fe423a38b917db02c30f1f5a/shapely-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8", size = 1832644, upload-time = "2025-09-24T13:50:44.886Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/ab/0bee5a830d209adcd3a01f2d4b70e587cdd9fd7380d5198c064091005af8/shapely-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a", size = 1642887, upload-time = "2025-09-24T13:50:46.735Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/5e/7d7f54ba960c13302584c73704d8c4d15404a51024631adb60b126a4ae88/shapely-2.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e", size = 2970931, upload-time = "2025-09-24T13:50:48.374Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/a2/83fc37e2a58090e3d2ff79175a95493c664bcd0b653dd75cb9134645a4e5/shapely-2.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6", size = 3082855, upload-time = "2025-09-24T13:50:50.037Z" },
+ { url = "https://files.pythonhosted.org/packages/44/2b/578faf235a5b09f16b5f02833c53822294d7f21b242f8e2d0cf03fb64321/shapely-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af", size = 3979960, upload-time = "2025-09-24T13:50:51.74Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/04/167f096386120f692cc4ca02f75a17b961858997a95e67a3cb6a7bbd6b53/shapely-2.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd", size = 4142851, upload-time = "2025-09-24T13:50:53.49Z" },
+ { url = "https://files.pythonhosted.org/packages/48/74/fb402c5a6235d1c65a97348b48cdedb75fb19eca2b1d66d04969fc1c6091/shapely-2.1.2-cp313-cp313-win32.whl", hash = "sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350", size = 1541890, upload-time = "2025-09-24T13:50:55.337Z" },
+ { url = "https://files.pythonhosted.org/packages/41/47/3647fe7ad990af60ad98b889657a976042c9988c2807cf322a9d6685f462/shapely-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715", size = 1722151, upload-time = "2025-09-24T13:50:57.153Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/49/63953754faa51ffe7d8189bfbe9ca34def29f8c0e34c67cbe2a2795f269d/shapely-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40", size = 1834130, upload-time = "2025-09-24T13:50:58.49Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/ee/dce001c1984052970ff60eb4727164892fb2d08052c575042a47f5a9e88f/shapely-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b", size = 1642802, upload-time = "2025-09-24T13:50:59.871Z" },
+ { url = "https://files.pythonhosted.org/packages/da/e7/fc4e9a19929522877fa602f705706b96e78376afb7fad09cad5b9af1553c/shapely-2.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801", size = 3018460, upload-time = "2025-09-24T13:51:02.08Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/18/7519a25db21847b525696883ddc8e6a0ecaa36159ea88e0fef11466384d0/shapely-2.1.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0", size = 3095223, upload-time = "2025-09-24T13:51:04.472Z" },
+ { url = "https://files.pythonhosted.org/packages/48/de/b59a620b1f3a129c3fecc2737104a0a7e04e79335bd3b0a1f1609744cf17/shapely-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c", size = 4030760, upload-time = "2025-09-24T13:51:06.455Z" },
+ { url = "https://files.pythonhosted.org/packages/96/b3/c6655ee7232b417562bae192ae0d3ceaadb1cc0ffc2088a2ddf415456cc2/shapely-2.1.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99", size = 4170078, upload-time = "2025-09-24T13:51:08.584Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/8e/605c76808d73503c9333af8f6cbe7e1354d2d238bda5f88eea36bfe0f42a/shapely-2.1.2-cp313-cp313t-win32.whl", hash = "sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf", size = 1559178, upload-time = "2025-09-24T13:51:10.73Z" },
+ { url = "https://files.pythonhosted.org/packages/36/f7/d317eb232352a1f1444d11002d477e54514a4a6045536d49d0c59783c0da/shapely-2.1.2-cp313-cp313t-win_amd64.whl", hash = "sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c", size = 1739756, upload-time = "2025-09-24T13:51:12.105Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/c4/3ce4c2d9b6aabd27d26ec988f08cb877ba9e6e96086eff81bfea93e688c7/shapely-2.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223", size = 1831290, upload-time = "2025-09-24T13:51:13.56Z" },
+ { url = "https://files.pythonhosted.org/packages/17/b9/f6ab8918fc15429f79cb04afa9f9913546212d7fb5e5196132a2af46676b/shapely-2.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c", size = 1641463, upload-time = "2025-09-24T13:51:14.972Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/57/91d59ae525ca641e7ac5551c04c9503aee6f29b92b392f31790fcb1a4358/shapely-2.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df", size = 2970145, upload-time = "2025-09-24T13:51:16.961Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/cb/4948be52ee1da6927831ab59e10d4c29baa2a714f599f1f0d1bc747f5777/shapely-2.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf", size = 3073806, upload-time = "2025-09-24T13:51:18.712Z" },
+ { url = "https://files.pythonhosted.org/packages/03/83/f768a54af775eb41ef2e7bec8a0a0dbe7d2431c3e78c0a8bdba7ab17e446/shapely-2.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4", size = 3980803, upload-time = "2025-09-24T13:51:20.37Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/cb/559c7c195807c91c79d38a1f6901384a2878a76fbdf3f1048893a9b7534d/shapely-2.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc", size = 4133301, upload-time = "2025-09-24T13:51:21.887Z" },
+ { url = "https://files.pythonhosted.org/packages/80/cd/60d5ae203241c53ef3abd2ef27c6800e21afd6c94e39db5315ea0cbafb4a/shapely-2.1.2-cp314-cp314-win32.whl", hash = "sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566", size = 1583247, upload-time = "2025-09-24T13:51:23.401Z" },
+ { url = "https://files.pythonhosted.org/packages/74/d4/135684f342e909330e50d31d441ace06bf83c7dc0777e11043f99167b123/shapely-2.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c", size = 1773019, upload-time = "2025-09-24T13:51:24.873Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/05/a44f3f9f695fa3ada22786dc9da33c933da1cbc4bfe876fe3a100bafe263/shapely-2.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a", size = 1834137, upload-time = "2025-09-24T13:51:26.665Z" },
+ { url = "https://files.pythonhosted.org/packages/52/7e/4d57db45bf314573427b0a70dfca15d912d108e6023f623947fa69f39b72/shapely-2.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076", size = 1642884, upload-time = "2025-09-24T13:51:28.029Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/27/4e29c0a55d6d14ad7422bf86995d7ff3f54af0eba59617eb95caf84b9680/shapely-2.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1", size = 3018320, upload-time = "2025-09-24T13:51:29.903Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/bb/992e6a3c463f4d29d4cd6ab8963b75b1b1040199edbd72beada4af46bde5/shapely-2.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0", size = 3094931, upload-time = "2025-09-24T13:51:32.699Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/16/82e65e21070e473f0ed6451224ed9fa0be85033d17e0c6e7213a12f59d12/shapely-2.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26", size = 4030406, upload-time = "2025-09-24T13:51:34.189Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/75/c24ed871c576d7e2b64b04b1fe3d075157f6eb54e59670d3f5ffb36e25c7/shapely-2.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0", size = 4169511, upload-time = "2025-09-24T13:51:36.297Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/f7/b3d1d6d18ebf55236eec1c681ce5e665742aab3c0b7b232720a7d43df7b6/shapely-2.1.2-cp314-cp314t-win32.whl", hash = "sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735", size = 1602607, upload-time = "2025-09-24T13:51:37.757Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/f6/f09272a71976dfc138129b8faf435d064a811ae2f708cb147dccdf7aacdb/shapely-2.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9", size = 1796682, upload-time = "2025-09-24T13:51:39.233Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
[[package]]
name = "sse-starlette"
version = "3.4.4"