hermes-pmxt 0.3.0__py3-none-any.whl

hermes_pmxt/__init__.py

@@ -0,0 +1,101 @@
+"""
+hermes-pmxt -- Prediction market integration for Hermes Agent.
+
+Usage:
+    from hermes_pmxt import pmxt_search, pmxt_quote, pmxt_order, ...
+
+The package imports without pmxt installed. Tools that require pmxt
+will raise ImportError with a helpful message at call time.
+"""
+
+from hermes_pmxt.config import (
+    get_mode,
+    get_base_url,
+    runtime_status,
+    runtime_status_str,
+)
+from hermes_pmxt.exchanges import (
+    is_pmxt_available,
+)
+from hermes_pmxt.registry import (
+    TOOLS as PMXT_TOOLS,
+    KNOWN_EXCHANGES,
+    get_tool,
+    list_tools,
+    is_destructive,
+    requires_credentials,
+)
+from hermes_pmxt.shaper import (
+    shape_result,
+)
+
+from hermes_pmxt.tools import (
+    pmxt_arbitrage_scan,
+    pmxt_balance,
+    pmxt_build_order,
+    pmxt_call,
+    pmxt_cancel_order,
+    pmxt_compare_market,
+    pmxt_events,
+    pmxt_execution_price,
+    pmxt_list_exchanges,
+    pmxt_ohlcv,
+    pmxt_order,
+    pmxt_order_book,
+    pmxt_portfolio,
+    pmxt_positions,
+    pmxt_quote,
+    pmxt_runtime_status,
+    pmxt_search,
+    pmxt_server_health,
+    pmxt_server_start,
+    pmxt_server_status,
+    pmxt_server_stop,
+    pmxt_submit_order,
+    pmxt_trades,
+)
+
+__version__ = "0.3.0"
+
+__all__ = [
+    # Config
+    "get_mode",
+    "get_base_url",
+    "runtime_status",
+    "runtime_status_str",
+    # Exchange
+    "is_pmxt_available",
+    "pmxt_list_exchanges",
+    "pmxt_runtime_status",
+    # Registry
+    "PMXT_TOOLS",
+    "KNOWN_EXCHANGES",
+    "get_tool",
+    "list_tools",
+    "is_destructive",
+    "requires_credentials",
+    # Shaper
+    "shape_result",
+    # Tools
+    "pmxt_call",
+    "pmxt_search",
+    "pmxt_quote",
+    "pmxt_order_book",
+    "pmxt_ohlcv",
+    "pmxt_trades",
+    "pmxt_events",
+    "pmxt_execution_price",
+    "pmxt_compare_market",
+    "pmxt_balance",
+    "pmxt_positions",
+    "pmxt_portfolio",
+    "pmxt_order",
+    "pmxt_build_order",
+    "pmxt_submit_order",
+    "pmxt_cancel_order",
+    "pmxt_arbitrage_scan",
+    "pmxt_server_health",
+    "pmxt_server_status",
+    "pmxt_server_start",
+    "pmxt_server_stop",
+]

hermes_pmxt/config.py

@@ -0,0 +1,145 @@
+"""
+Runtime configuration and mode detection for hermes-pmxt.
+
+Handles:
+  - PMXT_API_KEY, PMXT_API_URL, PMXT_BASE_URL, PMXT_WALLET_ADDRESS, PMXT_PRIVATE_KEY
+  - Hosted vs local sidecar vs custom server detection
+  - Capability reporting
+
+All functions work without pmxt installed.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Environment variable sources (ordered by precedence)
+# ---------------------------------------------------------------------------
+
+_HOSTED_URL = "https://api.pmxt.dev"
+_TRADE_URL = "https://trade.pmxt.dev"
+_LOCAL_URL = "http://localhost:3847"
+
+
+def _get_api_key() -> Optional[str]:
+    """Return the PMXT API key if configured."""
+    return os.getenv("PMXT_API_KEY") or None
+
+
+def _get_api_url() -> Optional[str]:
+    """Return the explicit API URL override."""
+    return os.getenv("PMXT_API_URL") or os.getenv("PMXT_BASE_URL") or None
+
+
+def get_mode() -> str:
+    """
+    Detect the PMXT runtime mode.
+
+    Returns one of:
+      - 'hosted': PMXT_API_KEY is set, talks to api.pmxt.dev (or custom URL)
+      - 'custom': PMXT_API_URL / PMXT_BASE_URL is set, custom server
+      - 'local-sidecar': no key and no URL, assumes localhost:3847
+      - 'unconfigured': not even local mode (no sidecar detectable)
+    """
+    key = _get_api_key()
+    url = _get_api_url()
+
+    if url:
+        return "custom"
+    if key:
+        return "hosted"
+    return "local-sidecar"
+
+
+def get_base_url() -> str:
+    """Return the base URL the SDK should use."""
+    url = _get_api_url()
+    if url:
+        return url.rstrip("/")
+    if _get_api_key():
+        return _HOSTED_URL
+    return _LOCAL_URL
+
+
+def get_trade_url() -> str:
+    """Return the hosted trade URL (for writes/account state)."""
+    url = os.getenv("PMXT_TRADE_URL")
+    if url:
+        return url.rstrip("/")
+    return _TRADE_URL
+
+
+def get_wallet_address() -> Optional[str]:
+    """Return the configured wallet address for hosted trading."""
+    return os.getenv("PMXT_WALLET_ADDRESS") or None
+
+
+def get_private_key() -> Optional[str]:
+    """Return the configured private key for hosted trading."""
+    return os.getenv("PMXT_PRIVATE_KEY") or None
+
+
+# ---------------------------------------------------------------------------
+# Runtime status
+# ---------------------------------------------------------------------------
+
+
+def runtime_status() -> dict:
+    """
+    Return a comprehensive runtime status dict.
+
+    Works without pmxt installed. When pmxt is available, adds
+    version, sidecar status, and exchange availability info.
+    """
+    result: dict = {
+        "mode": get_mode(),
+        "base_url": get_base_url(),
+        "has_api_key": _get_api_key() is not None,
+        "has_wallet_address": get_wallet_address() is not None,
+        "has_private_key": get_private_key() is not None,
+        "pmxt_installed": False,
+        "pmxt_version": None,
+        "python_version": sys.version,
+    }
+
+    try:
+        from hermes_pmxt.exchanges import is_pmxt_available as _available
+
+        if _available():
+            import importlib.metadata as _metadata
+            import pmxt  # type: ignore[import-untyped]
+
+            result["pmxt_installed"] = True
+            result["pmxt_version"] = getattr(pmxt, "__version__", None) or _metadata.version("pmxt")
+
+            # Sidecar status (best effort)
+            try:
+                s = pmxt.server.status()
+                if isinstance(s, dict):
+                    result["sidecar_running"] = s.get("running", False)
+                    result["sidecar_port"] = s.get("port")
+                    result["sidecar_pid"] = s.get("pid")
+            except Exception:
+                result["sidecar_running"] = False
+    except ImportError:
+        pass
+
+    return result
+
+
+def runtime_status_str() -> str:
+    """Return a human-readable one-liner of runtime status."""
+    status = runtime_status()
+    parts = [f"mode={status['mode']}", f"url={status['base_url']}"]
+    if status["pmxt_installed"]:
+        parts.append(f"pmxt={status['pmxt_version'] or '?'}")
+        if status.get("sidecar_running"):
+            parts.append(f"sidecar=:{status.get('sidecar_port','?')}")
+        else:
+            parts.append("sidecar=off")
+    else:
+        parts.append("pmxt=not_installed")
+    return " ".join(parts)

hermes_pmxt/exchanges.py

@@ -0,0 +1,187 @@
+"""Exchange initialization, normalization, and sidecar helpers for pmxt."""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Optional
+
+_pmxt_module = None
+_pmxt_import_error: Optional[str] = None
+
+
+def _get_pmxt():
+    """Lazy-import pmxt. Raises ImportError only when pmxt functionality is actually used."""
+    global _pmxt_module, _pmxt_import_error
+    if _pmxt_module is not None:
+        return _pmxt_module
+    if _pmxt_import_error is not None:
+        raise ImportError(_pmxt_import_error)
+    try:
+        import pmxt as _mod
+
+        _pmxt_module = _mod
+        return _pmxt_module
+    except ImportError as exc:
+        _pmxt_import_error = (
+            "pmxt is not installed. Run: pip install pmxt. "
+            "Depending on your pmxt version, you may also need a pmxtjs sidecar."
+        )
+        raise ImportError(_pmxt_import_error) from exc
+
+
+def is_pmxt_available() -> bool:
+    """Return True if pmxt can be imported, False otherwise."""
+    try:
+        _get_pmxt()
+        return True
+    except ImportError:
+        return False
+
+
+_exchange_cache: dict[str, object] = {}
+
+EXCHANGES = (
+    "polymarket",
+    "polymarket_us",
+    "kalshi",
+    "limitless",
+    "myriad",
+    "opinion",
+    "metaculus",
+    "smarkets",
+)
+
+TRADING_EXCHANGES = (
+    "polymarket",
+    "polymarket_us",
+    "kalshi",
+    "limitless",
+)
+
+_ALIASES = {
+    "polymarket-us": "polymarket_us",
+    "polymarket us": "polymarket_us",
+    "polymarketus": "polymarket_us",
+}
+
+
+def normalize_exchange_name(name: str) -> str:
+    """Normalize a user-facing exchange name to the package's canonical form."""
+    normalized = name.lower().strip().replace("-", "_")
+    normalized = _ALIASES.get(normalized, normalized)
+    return normalized.replace(" ", "_")
+
+
+def _exchange_class(name: str):
+    """Resolve the pmxt exchange class for a normalized exchange name."""
+    normalized = normalize_exchange_name(name)
+    class_name = "".join(part.capitalize() for part in normalized.split("_"))
+    pmxt = _get_pmxt()
+    return getattr(pmxt, class_name, None)
+
+
+def available_exchange_names() -> list[str]:
+    """Return exchange names that appear to exist in the installed pmxt build."""
+    return [name for name in EXCHANGES if _exchange_class(name) is not None]
+
+
+def ensure_server() -> tuple[bool, Optional[str]]:
+    """Ensure the pmxt sidecar server is running. Returns (ok, error_msg)."""
+    pmxt = _get_pmxt()
+    try:
+        if not pmxt.server.health():
+            pmxt.server.start()
+            time.sleep(1.5)
+        if not pmxt.server.health():
+            return False, "Sidecar server failed to start"
+        return True, None
+    except Exception as e:
+        return False, f"Sidecar server error: {e}"
+
+
+def get_exchange(name: str) -> tuple[Optional[object], Optional[str]]:
+    """
+    Get or initialize an exchange. Cached after first call.
+    Returns (exchange_instance, error_msg).
+    """
+    normalized = normalize_exchange_name(name)
+
+    if normalized in _exchange_cache:
+        return _exchange_cache[normalized], None
+
+    try:
+        exchange = _create_exchange(normalized)
+        _exchange_cache[normalized] = exchange
+        return exchange, None
+    except Exception as e:
+        return None, f"Failed to initialize {normalized}: {e}"
+
+
+def _create_exchange(name: str):
+    """Instantiate an exchange by normalized name."""
+    normalized = normalize_exchange_name(name)
+    pmxt = _get_pmxt()
+
+    if normalized == "polymarket":
+        return pmxt.Polymarket(
+            private_key=os.getenv("POLYMARKET_PRIVATE_KEY"),
+            proxy_address=os.getenv("POLYMARKET_PROXY_ADDRESS"),
+            signature_type="gnosis-safe",
+        )
+    if normalized == "polymarket_us":
+        cls = _exchange_class(normalized)
+        if cls is None:
+            raise ValueError("Exchange polymarket_us is not available in this pmxt version")
+        return cls(
+            api_key=os.getenv("POLYMARKET_US_API_KEY"),
+            private_key=os.getenv("POLYMARKET_US_PRIVATE_KEY"),
+        )
+    if normalized == "kalshi":
+        return pmxt.Kalshi(
+            api_key=os.getenv("KALSHI_API_KEY"),
+            private_key=os.getenv("KALSHI_PRIVATE_KEY"),
+        )
+    if normalized == "limitless":
+        return pmxt.Limitless(
+            api_key=os.getenv("LIMITLESS_API_KEY"),
+            private_key=os.getenv("LIMITLESS_PRIVATE_KEY"),
+        )
+
+    cls = _exchange_class(normalized)
+    if cls is None:
+        raise ValueError(f"Unknown exchange: {normalized}")
+    return cls()
+
+
+def server_status() -> dict:
+    """Get sidecar server status."""
+    pmxt = _get_pmxt()
+    try:
+        status = pmxt.server.status()
+        if isinstance(status, dict):
+            return {
+                "running": status.get("running", False),
+                "pid": status.get("pid"),
+                "port": status.get("port"),
+                "version": status.get("version"),
+                "uptime_seconds": status.get("uptimeSeconds") or status.get("uptime_seconds"),
+            }
+        return {
+            "running": getattr(status, "running", False),
+            "pid": getattr(status, "pid", None),
+            "port": getattr(status, "port", None),
+            "version": getattr(status, "version", None),
+            "uptime_seconds": getattr(status, "uptimeSeconds", None),
+        }
+    except Exception as e:
+        return {"running": False, "error": str(e)}
+
+
+def server_logs(n: int = 50) -> list[str]:
+    """Get last N lines of server logs."""
+    pmxt = _get_pmxt()
+    try:
+        return list(pmxt.server.logs(n))
+    except Exception:
+        return []

hermes_pmxt/registry.py

@@ -0,0 +1,251 @@
+"""
+Generated tool registry for PMXT methods.
+
+Maps PMXT API methods to Python-friendly names with:
+  - arg specs for positional reconstruction
+  - safety annotations (read_only, destructive, idempotent)
+  - credential requirements
+  - supported exchanges
+
+This file serves as a static snapshot. For auto-generation from PMXT
+OpenAPI specs, run: python scripts/sync_pmxt_registry.py
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Arg spec
+# ---------------------------------------------------------------------------
+
+
+class ArgSpec:
+    """Describes a single positional argument for a PMXT API method."""
+
+    __slots__ = ("name", "kind", "optional", "flatten")
+
+    def __init__(self, name: str, kind: str = "object", optional: bool = True, flatten: bool = False):
+        self.name = name
+        self.kind = kind
+        self.optional = optional
+        self.flatten = flatten
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "optional": self.optional,
+            "flatten": self.flatten,
+        }
+
+
+# ---------------------------------------------------------------------------
+# Tool definition
+# ---------------------------------------------------------------------------
+
+
+class ToolDef:
+    """Definition of a single PMXT tool/method."""
+
+    __slots__ = ("name", "method", "description", "args", "read_only", "destructive",
+                 "idempotent", "requires_credentials", "category")
+
+    def __init__(
+        self,
+        name: str,
+        method: str,
+        description: str,
+        args: Optional[list[ArgSpec]] = None,
+        read_only: bool = True,
+        destructive: bool = False,
+        idempotent: bool = False,
+        requires_credentials: bool = False,
+        category: str = "data",
+    ):
+        self.name = name
+        self.method = method
+        self.description = description
+        self.args = args or []
+        self.read_only = read_only
+        self.destructive = destructive
+        self.idempotent = idempotent
+        self.requires_credentials = requires_credentials
+        self.category = category
+
+
+# ---------------------------------------------------------------------------
+# Supported exchanges (from pmxt-mcp generated tools.ts, v2.50.x)
+# ---------------------------------------------------------------------------
+
+KNOWN_EXCHANGES = [
+    "polymarket",
+    "polymarket_us",
+    "kalshi",
+    "kalshi-demo",
+    "limitless",
+    "probable",
+    "baozi",
+    "myriad",
+    "opinion",
+    "metaculus",
+    "smarkets",
+    "gemini-titan",
+    "hyperliquid",
+    "suibets",
+    "rain",
+    "mock",
+    "router",
+]
+
+# Aliases for user-facing exchange names
+EXCHANGE_ALIASES: dict[str, str] = {
+    "polymarket-us": "polymarket_us",
+    "polymarket us": "polymarket_us",
+    "polymarketus": "polymarket_us",
+    "kalshi-demo": "kalshi-demo",
+    "kalshi demo": "kalshi-demo",
+    "gemini-titan": "gemini-titan",
+    "gemini titan": "gemini-titan",
+}
+
+
+# ---------------------------------------------------------------------------
+# Tool registry (static snapshot)
+# ---------------------------------------------------------------------------
+
+
+def _a(name: str, kind: str = "object", optional: bool = True, flatten: bool = False) -> ArgSpec:
+    return ArgSpec(name, kind, optional, flatten)
+
+
+TOOLS: list[ToolDef] = [
+    # --- Market & Event Data ---
+    ToolDef("fetchMarkets", "fetchMarkets", "Search tradeable markets by query/slug/category.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchMarketsPaginated", "fetchMarketsPaginated",
+            "Paginated market fetch with cursor snapshot. First call w/o cursor fetches all; subsequent cursor calls slice from cache.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchEvents", "fetchEvents", "Search event groups (broad topics) containing child markets.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchEventsPaginated", "fetchEventsPaginated",
+            "Paginated event fetch with cursor snapshot.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchMarket", "fetchMarket", "Fetch a single market by ID, slug, or URL.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchEvent", "fetchEvent", "Fetch a single event by ID or slug.",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchSeries", "fetchSeries", "Fetch series (4th tier below event/market/outcome).",
+            [_a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("loadMarkets", "loadMarkets", "Load and cache all markets locally. Recommended for stable iteration.",
+            [], read_only=True, idempotent=True, category="data"),
+
+    # --- Order Book & Pricing ---
+    ToolDef("fetchOHLCV", "fetchOHLCV", "Get price history candles for an outcome.",
+            [_a("outcomeId", "string", optional=False),
+             _a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchOrderBook", "fetchOrderBook", "Get current order book depth for an outcome.",
+            [_a("outcomeId", "string", optional=False),
+             _a("limit", "number"),
+             _a("params", flatten=True)], read_only=True, category="data"),
+    ToolDef("fetchOrderBooks", "fetchOrderBooks", "Batch fetch order books for multiple outcome IDs.",
+            [_a("outcomeIds", "unknown", optional=False)], read_only=True, category="data"),
+    ToolDef("fetchTrades", "fetchTrades", "Get recent trades for an outcome.",
+            [_a("outcomeId", "string", optional=False),
+             _a("params", flatten=True)], read_only=True, category="data"),
+
+    # --- Order Management ---
+    ToolDef("createOrder", "createOrder", "Place an order directly. DESTRUCTIVE -- requires user confirmation.",
+            [_a("params", flatten=True)], destructive=True, requires_credentials=True, category="trading"),
+    ToolDef("buildOrder", "buildOrder", "Build (sign/preview) an order without submitting.",
+            [_a("params", flatten=True)], read_only=True, idempotent=True, requires_credentials=True, category="trading"),
+    ToolDef("submitOrder", "submitOrder", "Submit a pre-built order. DESTRUCTIVE -- requires user confirmation.",
+            [_a("built", "object", optional=False)], destructive=True, requires_credentials=True, category="trading"),
+    ToolDef("cancelOrder", "cancelOrder", "Cancel an open order. DESTRUCTIVE -- requires user confirmation.",
+            [_a("orderId", "string", optional=False)], destructive=True, requires_credentials=True, category="trading"),
+    ToolDef("fetchOrder", "fetchOrder", "Fetch a single order by ID.",
+            [_a("orderId", "string", optional=False)], read_only=True, requires_credentials=True, category="trading"),
+    ToolDef("fetchOpenOrders", "fetchOpenOrders", "Fetch open orders, optionally filtered by market.",
+            [_a("marketId", "string")], read_only=True, requires_credentials=True, category="trading"),
+    ToolDef("fetchClosedOrders", "fetchClosedOrders", "Fetch closed/filled orders.",
+            [_a("params", flatten=True)], read_only=True, requires_credentials=True, category="trading"),
+    ToolDef("fetchAllOrders", "fetchAllOrders", "Fetch all orders (open + closed).",
+            [_a("params", flatten=True)], read_only=True, requires_credentials=True, category="trading"),
+    ToolDef("fetchMyTrades", "fetchMyTrades", "Fetch user's filled trades.",
+            [_a("params", flatten=True)], read_only=True, requires_credentials=True, category="trading"),
+
+    # --- Account & Positions ---
+    ToolDef("fetchBalance", "fetchBalance", "Get account balance.",
+            [_a("address", "string")], read_only=True, requires_credentials=True, category="account"),
+    ToolDef("fetchPositions", "fetchPositions", "Get open positions.",
+            [_a("address", "string")], read_only=True, requires_credentials=True, category="account"),
+
+    # --- Router / Cross-Venue ---
+    ToolDef("compareMarketPrices", "compareMarketPrices", "Compare live prices across venues side-by-side.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+    ToolDef("fetchMarketMatches", "fetchMarketMatches", "Find the same or related market on other venues.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+    ToolDef("fetchEventMatches", "fetchEventMatches", "Find matching events across venues.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+    ToolDef("fetchRelatedMarkets", "fetchRelatedMarkets", "Fetch markets related to a given market.",
+            [_a("params", "object", optional=False)], read_only=True, category="router"),
+    ToolDef("fetchMatchedMarkets", "fetchMatchedMarkets", "Fetch all matched market pairs from the catalog.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+    ToolDef("fetchMatchedPrices", "fetchMatchedPrices", "Fetch prices for matched market pairs.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+    ToolDef("fetchHedges", "fetchHedges", "Find hedging opportunities across venues.",
+            [_a("params", "object", optional=False)], read_only=True, category="router"),
+    ToolDef("fetchArbitrage", "fetchArbitrage", "Find arbitrage opportunities across venues.",
+            [_a("params", flatten=True)], read_only=True, category="router"),
+
+    # --- Execution & Pricing ---
+    ToolDef("getExecutionPrice", "getExecutionPrice",
+            "Calculate VWAP execution price from order book.",
+            [_a("orderBook", "object", optional=False),
+             _a("side", "string", optional=False),
+             _a("amount", "number", optional=False)],
+            read_only=True, idempotent=True, category="data"),
+    ToolDef("getExecutionPriceDetailed", "getExecutionPriceDetailed",
+            "Detailed execution price including fill status.",
+            [_a("orderBook", "object", optional=False),
+             _a("side", "string", optional=False),
+             _a("amount", "number", optional=False)],
+            read_only=True, idempotent=True, category="data"),
+]
+
+# Index by Python method name
+TOOLS_BY_NAME: dict[str, ToolDef] = {t.method: t for t in TOOLS}
+
+# Category lists
+READ_ONLY_TOOLS = [t for t in TOOLS if t.read_only and not t.destructive]
+DESTRUCTIVE_TOOLS = [t for t in TOOLS if t.destructive]
+CREDENTIAL_TOOLS = [t for t in TOOLS if t.requires_credentials]
+
+
+def get_tool(method: str) -> Optional[ToolDef]:
+    """Look up a tool definition by PMXT method name."""
+    return TOOLS_BY_NAME.get(method)
+
+
+def list_tools(category: Optional[str] = None, read_only: Optional[bool] = None) -> list[ToolDef]:
+    """List tools, optionally filtered by category or read_only flag."""
+    result = TOOLS
+    if category:
+        result = [t for t in result if t.category == category]
+    if read_only is True:
+        result = [t for t in result if t.read_only and not t.destructive]
+    elif read_only is False:
+        result = [t for t in result if not t.read_only or t.destructive]
+    return result
+
+
+def is_destructive(method: str) -> bool:
+    """Return True if the method is destructive (requires user confirmation)."""
+    tool = get_tool(method)
+    return tool is not None and tool.destructive
+
+
+def requires_credentials(method: str) -> bool:
+    """Return True if the method requires exchange credentials."""
+    tool = get_tool(method)
+    return tool is not None and tool.requires_credentials