File size: 6,553 Bytes
f726fd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | """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: # pragma: no cover
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: # pragma: no cover - defensive envelope guard
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
|