| """Tool registry and dispatcher for the C_20_01_01 ticketing runtime.""" |
| from __future__ import annotations |
|
|
| import hashlib |
| import importlib |
| import shutil |
| import tempfile |
| from contextlib import contextmanager |
| from pathlib import Path |
| from typing import Any, Callable, Dict, List, Optional |
|
|
| try: |
| import fcntl |
| except ImportError: |
| fcntl = None |
|
|
| TOOL_REGISTRY: Dict[str, Callable[..., Dict[str, Any]]] = {} |
| _TOOL_METADATA: Dict[str, Dict[str, Any]] = {} |
| _state_manager = None |
| _runtime_root: Optional[Path] = None |
| _TOOL_LOADED = False |
|
|
|
|
| def register_tool(name: str, func: Callable[..., Dict[str, Any]], description: str, input_schema: Dict[str, Any]) -> None: |
| _TOOL_METADATA[name] = {"name": name, "function": func, "description": description, "input_schema": input_schema} |
| TOOL_REGISTRY[name] = func |
|
|
|
|
| TOOL_MODULES: List[str] = [ |
| 'mcp_servers.tools.list_venues', |
| 'mcp_servers.tools.get_venue_seating_chart', |
| 'mcp_servers.tools.list_events', |
| 'mcp_servers.tools.get_event_sales_dashboard', |
| 'mcp_servers.tools.list_performances', |
| 'mcp_servers.tools.list_price_tiers', |
| 'mcp_servers.tools.list_ticket_types', |
| 'mcp_servers.tools.search_customers', |
| 'mcp_servers.tools.get_customer_orders', |
| 'mcp_servers.tools.get_order', |
| 'mcp_servers.tools.search_tickets', |
| 'mcp_servers.tools.get_entry_statistics', |
| 'mcp_servers.tools.create_event', |
| 'mcp_servers.tools.update_event_status', |
| 'mcp_servers.tools.create_venue_section', |
| 'mcp_servers.tools.update_seat_status', |
| 'mcp_servers.tools.create_price_tier', |
| 'mcp_servers.tools.update_price_tier', |
| 'mcp_servers.tools.create_ticket_type', |
| 'mcp_servers.tools.update_ticket_type', |
| 'mcp_servers.tools.create_discount_campaign', |
| 'mcp_servers.tools.update_discount_campaign', |
| 'mcp_servers.tools.create_customer', |
| 'mcp_servers.tools.create_order', |
| 'mcp_servers.tools.add_order_line', |
| 'mcp_servers.tools.assign_seats_to_order_line', |
| 'mcp_servers.tools.record_entry_scan', |
| 'mcp_servers.tools.release_ticket_inventory', |
| 'mcp_servers.tools.apply_discount_to_order', |
| 'mcp_servers.tools.finalize_order_to_tickets', |
| 'mcp_servers.tools.request_refund', |
| 'mcp_servers.tools.approve_refund_request', |
| 'mcp_servers.tools.reject_refund_request', |
| 'mcp_servers.tools.assign_ticket_holder', |
| 'mcp_servers.tools.update_entry_summary_reconciliation', |
| 'mcp_servers.tools.cancel_event_and_void_tickets' |
| ] |
| STATIC_TOOL_REGISTRY: Dict[str, Callable[..., Dict[str, Any]]] = {} |
|
|
|
|
| def load_tools() -> None: |
| global _TOOL_LOADED, STATIC_TOOL_REGISTRY |
| if _TOOL_LOADED: |
| return |
| for module_name in TOOL_MODULES: |
| importlib.import_module(module_name) |
| STATIC_TOOL_REGISTRY = dict(TOOL_REGISTRY) |
| _TOOL_LOADED = True |
|
|
|
|
| def get_tool_names_for_environment() -> List[str]: |
| load_tools() |
| return sorted(TOOL_REGISTRY) |
|
|
|
|
| def get_tool_metadata() -> Dict[str, Dict[str, Any]]: |
| load_tools() |
| return {name: {k: v for k, v in meta.items() if k != "function"} for name, meta in _TOOL_METADATA.items()} |
|
|
|
|
| def call_tool(tool_name: str, state_manager=None, **kwargs) -> Dict[str, Any]: |
| load_tools() |
| func = TOOL_REGISTRY.get(tool_name) |
| if func is None: |
| return {"type": "tool_result", "tool": tool_name, "content": {"status": "error", "data": {}, "message": f"UNKNOWN_TOOL: {tool_name}"}} |
| sm = state_manager if state_manager is not None else get_state_manager() |
| try: |
| content = func(state_manager=sm, **kwargs) |
| except Exception as exc: |
| content = {"status": "error", "data": {}, "message": f"INTERNAL_ERROR: {type(exc).__name__}: {exc}"} |
| if not isinstance(content, dict) or "status" not in content: |
| content = {"status": "error", "data": {}, "message": "TOOL_RESPONSE_INVALID: missing status"} |
| return {"type": "tool_result", "tool": tool_name, "content": content} |
|
|
|
|
| def _resolve_data_root(db_path: str) -> Path: |
| base = Path(db_path) |
| if base.is_absolute(): |
| return base.resolve() |
| candidate = (Path.cwd() / base).resolve() |
| if candidate.exists(): |
| return candidate |
| return (Path(__file__).resolve().parent.parent / base).resolve() |
|
|
|
|
| def _copy_seed_database(source_root: Path, runtime_root: Path) -> None: |
| src = source_root / "database" |
| runtime_db = runtime_root / "database" |
| runtime_temp = runtime_root / "temp" |
| runtime_root.mkdir(parents=True, exist_ok=True) |
| if src.exists(): |
| shutil.copytree(src, runtime_db, copy_function=os.link if False else shutil.copy2) |
| shutil.copytree(src, runtime_temp, copy_function=os.link if False else shutil.copy2) |
| else: |
| runtime_db.mkdir(parents=True, exist_ok=True) |
| runtime_temp.mkdir(parents=True, exist_ok=True) |
|
|
|
|
| def cleanup_runtime() -> None: |
| global _state_manager, _runtime_root |
| old = _runtime_root |
| _state_manager = None |
| _runtime_root = None |
| if old is not None: |
| shutil.rmtree(old, ignore_errors=True) |
|
|
|
|
| @contextmanager |
| def _database_init_lock(db_path: str): |
| resolved = _resolve_data_root(db_path) |
| digest = hashlib.sha256(str(resolved).encode("utf-8")).hexdigest()[:16] |
| lock_dir = Path(tempfile.gettempdir()) / "c_20_01_01_locks" |
| lock_dir.mkdir(parents=True, exist_ok=True) |
| lock_path = lock_dir / f"{digest}.lock" |
| handle = lock_path.open("a+") |
| try: |
| if fcntl is not None: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| yield |
| finally: |
| if fcntl is not None: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
| handle.close() |
|
|
|
|
| def init_database(db_path: str = "data") -> None: |
| global _state_manager, _runtime_root |
| source_root = _resolve_data_root(db_path) |
| with _database_init_lock(str(source_root)): |
| previous = _runtime_root |
| runtime_root = Path(tempfile.mkdtemp(prefix="c_20_01_01_runtime_")) |
| try: |
| src = source_root / "database" |
| shutil.copytree(src, runtime_root / "database") |
| shutil.copytree(src, runtime_root / "temp") |
| from mcp_servers.state.state_manager import StateManager |
| _state_manager = StateManager(db_path=str(runtime_root)) |
| _runtime_root = runtime_root |
| finally: |
| if previous is not None and previous != _runtime_root: |
| shutil.rmtree(previous, ignore_errors=True) |
|
|
|
|
| def get_state_manager(): |
| if _state_manager is None: |
| init_database("data") |
| return _state_manager |
|
|
