vrymdor-node 1.1.0__py3-none-any.whl

vrymdor_mcp.py

@@ -0,0 +1,235 @@
+"""vrymdor-mcp: connect Claude Desktop, Cursor, VS Code or any MCP client to your Vrymdor AI Node, no Docker needed.
+
+Desktop MCP clients start a local command and talk to it over standard input and output. This command relays each
+message to your node's MCP endpoint (POST /mcp) and writes the node's answer back. It trades the Agent ID and Agent
+Secret for a short-lived token and renews it a minute before it expires, so the client never handles a token.
+
+    uvx --from vrymdor-node vrymdor-mcp            # what the MCP client runs
+    uvx --from vrymdor-node vrymdor-mcp --check    # one-time test: does the node accept this agent?
+
+Settings come from the environment (the MCP client's "env" block):
+
+    VRYMNOX_NODE_URL      your Node Host URL, for example https://node.vrymdor.com/t/abc123def456
+                          or http://localhost:8080 for a node on this computer
+    VRYMNOX_AGENT_ID      agt_...
+    VRYMNOX_AGENT_SECRET  vrym_agent_...
+
+The VRYMDOR_ spellings (VRYMDOR_NODE_URL and so on, as in the GitHub Action) work too. Standard output carries only
+MCP messages; anything for a person goes to standard error.
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import sys
+import time
+from typing import TextIO
+
+import httpx
+
+NAMES = {"url": ("VRYMNOX_NODE_URL", "VRYMDOR_NODE_URL"),
+         "id": ("VRYMNOX_AGENT_ID", "VRYMDOR_AGENT_ID"),
+         "secret": ("VRYMNOX_AGENT_SECRET", "VRYMDOR_AGENT_SECRET")}
+
+
+def version() -> str:
+    try:
+        from importlib.metadata import version as _v
+
+        return _v("vrymdor-node")
+    except Exception:  # noqa: BLE001 (running from a source checkout)
+        return "0"
+
+
+def user_agent() -> str:
+    # Our own name: a stock library name (Python-urllib, python-httpx) can be refused by Cloudflare's browser check in
+    # front of a hosted node.
+    return f"vrymdor-mcp/{version()}"
+
+
+def clean_url(raw: str) -> str:
+    """Forgive the usual paste mistakes: spaces, quotes, a slash at the end, or the Token URL ending in /v1/token."""
+    url = raw.strip().strip("\"'").strip().rstrip("/")
+    if url.endswith("/v1/token"):
+        url = url[: -len("/v1/token")].rstrip("/")
+    return url
+
+
+def setting(key: str, env: dict | None = None) -> str:
+    env = os.environ if env is None else env
+    for name in NAMES[key]:
+        if env.get(name, "").strip():
+            return env[name].strip().strip("\"'").strip()
+    return ""
+
+
+def refusal(status: int, raw: bytes) -> str:
+    """Why the token was refused, in words: the node's own reason, or that something in front of it answered."""
+    text = (raw or b"")[:2000].decode("utf-8", "replace")
+    try:
+        doc = json.loads(text)
+        detail = doc.get("detail") or doc.get("error") if isinstance(doc, dict) else None
+    except ValueError:
+        detail = None
+    if isinstance(detail, dict):
+        detail = detail.get("message") or detail.get("code")
+    if detail:
+        return f"the node refused the agent (HTTP {status}): {str(detail)[:200]}"
+    low = text.lower()
+    if "cloudflare" in low or "error code: 10" in low:
+        return (f"the request was blocked before it reached the node (HTTP {status}, Cloudflare). Check the Node Host "
+                "URL is the one from your Vrymdor dashboard")
+    if status == 401:
+        return "the node refused the agent (HTTP 401): the Agent ID or Agent Secret is wrong"
+    if status == 404:
+        return "the node answered 404: the Node Host URL is wrong. Copy it again from your Vrymdor dashboard"
+    if status in (502, 503, 504):
+        return f"the node is not answering (HTTP {status}). If it is a hosted node, turn it on in Home base"
+    return f"the node refused the agent (HTTP {status})"
+
+
+class Bridge:
+    def __init__(self, url: str, agent_id: str, secret: str, *, http: httpx.Client | None = None) -> None:
+        self.url, self.agent_id, self._secret = clean_url(url), agent_id, secret
+        self._http = http or httpx.Client(timeout=120.0, headers={"User-Agent": user_agent()})
+        self._token, self._expires = "", 0.0
+        self._session = ""
+
+    def token(self) -> str:
+        if self._token and time.time() < self._expires - 60:
+            return self._token
+        r = self._http.post(f"{self.url}/v1/token", json={"agent_id": self.agent_id, "agent_secret": self._secret})
+        if r.status_code != 200:
+            raise RuntimeError(refusal(r.status_code, r.content))
+        doc = r.json()
+        self._token, self._expires = doc["access_token"], time.time() + int(doc.get("expires_in", 600))
+        return self._token
+
+    def _send(self, line: str) -> httpx.Response:
+        def post() -> httpx.Response:
+            headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream",
+                       "Authorization": f"Bearer {self.token()}"}
+            if self._session:
+                headers["Mcp-Session-Id"] = self._session
+            return self._http.post(f"{self.url}/mcp", content=line.encode("utf-8"), headers=headers)
+
+        r = post()
+        if r.status_code == 401:   # the token was revoked or the node restarted: get a fresh one and try once more
+            self._token, self._expires = "", 0.0
+            r = post()
+        if r.headers.get("mcp-session-id"):
+            self._session = r.headers["mcp-session-id"]
+        return r
+
+    def handle(self, line: str, err: TextIO = sys.stderr) -> str | None:
+        try:
+            msg = json.loads(line)
+        except ValueError:
+            return json.dumps({"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error"}})
+        has_id = isinstance(msg, dict) and "id" in msg
+        try:
+            r = self._send(line)
+        except (httpx.HTTPError, RuntimeError, ValueError, KeyError) as exc:
+            reason = why(exc, self.url)
+            print(f"vrymdor-mcp: {reason}", file=err, flush=True)
+            if has_id:
+                return json.dumps({"jsonrpc": "2.0", "id": msg.get("id"),
+                                   "error": {"code": -32603, "message": f"Your Vrymdor AI Node could not be reached: {reason}"}})
+            return None
+        if r.status_code == 202 or not r.content:
+            return None   # a notification
+        text = r.content.decode("utf-8")
+        if r.headers.get("content-type", "").split(";")[0].strip().lower() == "text/event-stream":
+            return sse_messages(text) or None
+        return text
+
+
+def sse_messages(text: str) -> str:
+    """A streamed answer (text/event-stream): each event's data lines joined, one JSON message per output line."""
+    out, data = [], []
+    for raw in text.replace("\r\n", "\n").split("\n"):
+        if raw.startswith("data:"):
+            data.append(raw[5:].lstrip(" "))
+        elif raw == "" and data:
+            out.append("".join(data))
+            data = []
+    if data:
+        out.append("".join(data))
+    return "\n".join(m for m in out if m.strip())
+
+
+def why(exc: Exception, url: str) -> str:
+    """An exception in words: no connection is the usual case, and it is the address or a node that is off."""
+    if isinstance(exc, (httpx.ConnectError, httpx.ConnectTimeout)):
+        return f"could not reach {url} (check the Node Host URL, and that your node is on)"
+    if isinstance(exc, httpx.TimeoutException):
+        return f"{url} did not answer in time"
+    return str(exc)
+
+
+def _utf8(stream: TextIO) -> None:
+    # MCP messages are UTF-8 with \n line endings; a Windows console default (cp1252, \r\n) would damage them.
+    try:
+        stream.reconfigure(encoding="utf-8", newline="\n")   # type: ignore[attr-defined]
+    except (AttributeError, ValueError):
+        pass
+
+
+def check(bridge: Bridge, out: TextIO = sys.stdout) -> int:
+    """--check: get a token and list the tools, then say in words whether it works."""
+    try:
+        bridge.token()
+        doc = json.loads(bridge.handle(json.dumps({"jsonrpc": "2.0", "id": 1, "method": "tools/list"}),
+                                       err=io.StringIO()) or "{}")
+        if doc.get("error"):
+            raise RuntimeError(str(doc["error"].get("message") or doc["error"]).rstrip("."))
+        tools = [t.get("name") for t in doc.get("result", {}).get("tools", [])]
+    except (httpx.HTTPError, RuntimeError, ValueError, KeyError) as exc:
+        print(f"Not connected: {why(exc, bridge.url)}.", file=out)
+        return 1
+    if not tools:
+        print("Connected, but the node listed no tools for this agent. Check the agent's role in your policy.", file=out)
+        return 1
+    first = sorted(tools, key=lambda n: (n != "vrymnox_sanitize", not str(n).startswith("vrymnox_"), str(n)))[:4]
+    print(f"Connected: your node accepted this agent and offers {len(tools)} tools, including "
+          f"{', '.join(map(str, first))}.", file=out)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = sys.argv[1:] if argv is None else argv
+    if "--version" in args:
+        print(f"vrymdor-mcp {version()}")
+        return 0
+    if "-h" in args or "--help" in args:
+        print(__doc__)
+        return 0
+    missing = [NAMES[k][0] for k in ("url", "id", "secret") if not setting(k)]
+    if missing:
+        print(f"vrymdor-mcp: set {', '.join(missing)} (in your MCP client's env block)", file=sys.stderr)
+        return 2
+    url = setting("url")
+    if not url.startswith(("http://", "https://")):
+        print("vrymdor-mcp: VRYMNOX_NODE_URL must start with https:// (or http:// for a node on this computer)",
+              file=sys.stderr)
+        return 2
+    bridge = Bridge(url, setting("id"), setting("secret"))
+    if "--check" in args:
+        return check(bridge)
+    _utf8(sys.stdin)
+    _utf8(sys.stdout)
+    try:
+        for line in sys.stdin:
+            if line.strip():
+                out = bridge.handle(line.strip())
+                if out is not None:
+                    sys.stdout.write(out + "\n")
+                    sys.stdout.flush()
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vrymdor_node-1.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: vrymdor-node
+Version: 1.1.0
+Summary: Python client for the Vrymdor AI Node: governed tool, model and webhook calls, LangChain and LlamaIndex tools, and vrymdor-mcp, the MCP bridge for Claude Desktop, Cursor and VS Code.
+Author-email: Vrymnox Systems LLC <support@vrymdor.com>
+License-Expression: MIT
+Project-URL: Homepage, https://vrymdor.com
+Project-URL: Documentation, https://docs.vrymdor.com/ai-node.html
+Project-URL: Source, https://github.com/ernesthausmann15/vrymdor-node-python
+Project-URL: Issues, https://github.com/ernesthausmann15/vrymdor-node-python/issues
+Keywords: ai,agents,mcp,governance,pii,langchain,llamaindex,vrymdor
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3.49; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.12; extra == "llamaindex"
+Requires-Dist: pydantic>=2; extra == "llamaindex"
+Dynamic: license-file
+
+# vrymdor-node
+
+The Python client for the Vrymdor AI Node by Vrymnox Systems LLC. Every call goes through your node's
+checks: the agent's identity and status, your policy, removal of PII (personally identifiable information)
+and secrets, a signed request and a metadata-only audit record. One module, one dependency (httpx).
+
+## Install
+
+```bash
+pip install vrymdor-node                 # the client
+pip install "vrymdor-node[langchain]"    # plus LangChain tools
+pip install "vrymdor-node[llamaindex]"   # plus LlamaIndex tools
+```
+
+## Use
+
+You need your node's address and an agent registered in the Vrymdor app (AI agents, Register an agent).
+The agent secret is shown once.
+
+```python
+from vrymnox_node import VrymnoxNode
+
+node = VrymnoxNode("http://vrymdor-node:8080", agent_id="agt_...", agent_secret="vrym_agent_...")
+
+node.sanitize("Customer jane@acme.io called")         # "Customer [REDACTED:EMAIL] called"
+node.tool("github", "create_issue", {"title": "Login fails"})
+node.llm("anthropic", "v1/messages", {"model": "...", "messages": [...]})
+
+tools = node.langchain_tools()     # one LangChain StructuredTool per tool your policy allows
+tools = node.llamaindex_tools()    # the same, as LlamaIndex FunctionTools
+```
+
+A refusal raises `VrymnoxError` with a stable `code` (for example `tool_not_allowed`, `rate_limited`,
+`agent_stopped`) and `retryable`. An action your policy holds raises `VrymnoxHeld` (code
+`held_by_policy`): it did not run, and a held action is never released. Change the policy to allow it.
+
+Documentation: https://docs.vrymdor.com/ai-node.html
+
+## MCP: Claude Desktop, Cursor and VS Code, no Docker
+
+<!-- mcp-name: io.github.ernesthausmann15/vrymdor-mcp -->
+
+The package includes `vrymdor-mcp`, the bridge desktop MCP clients start as a local command. It relays each MCP
+message to your node and renews the agent's token by itself. The easiest way to run it is `uvx`, which also fetches
+a matching Python for you: install uv once (macOS and Linux: `curl -LsSf https://astral.sh/uv/install.sh | sh`;
+Windows PowerShell: `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`).
+
+Test the agent first (it prints "Connected: ..." or the reason it is not):
+
+```bash
+VRYMNOX_NODE_URL=https://node.vrymdor.com/t/abc123def456 VRYMNOX_AGENT_ID=agt_... \
+  VRYMNOX_AGENT_SECRET=vrym_agent_... uvx --from vrymdor-node vrymdor-mcp --check
+```
+
+Claude Desktop (`claude_desktop_config.json`) and Cursor (`mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "vrymdor": {
+      "command": "uvx",
+      "args": ["--from", "vrymdor-node", "vrymdor-mcp"],
+      "env": {
+        "VRYMNOX_NODE_URL": "https://node.vrymdor.com/t/abc123def456",
+        "VRYMNOX_AGENT_ID": "agt_...",
+        "VRYMNOX_AGENT_SECRET": "vrym_agent_..."
+      }
+    }
+  }
+}
+```
+
+VS Code (`.vscode/mcp.json`): the same block under `"servers"`, with `"type": "stdio"` added.
+
+If the client says it cannot find `uvx` (Claude Desktop on macOS starts commands without your shell's PATH), put
+the full path in `command`: the output of `which uvx` (macOS, Linux) or `where uvx` (Windows).
+
+## License
+
+MIT. The Vrymdor AI Node itself is licensed separately under your Vrymnox agreement.
+
+## License and terms
+
+Copyright (c) 2026 Vrymnox Systems LLC. This client is open source under the MIT License (LICENSE). Using the
+Vrymdor AI Node service it connects to is governed by the Vrymdor Master Subscription Agreement
+(https://vrymdor.com/msa) and the Acceptable Use Policy in the agreement set you accept when you sign up.

vrymdor_node-1.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+vrymdor_mcp.py,sha256=IYc0QBfKR4jp3GP0xuyZzaFra4w8Ufismrsx73JCkvI,10072
+vrymnox_node.py,sha256=nHeMGwvGlqzNFdxJfPfUY8A5McZTdZdl6kpGvEATtR4,7390
+vrymdor_node-1.1.0.dist-info/licenses/LICENSE,sha256=9xeKa3_q9zpsJG_jIQRTv4Cznxll2hyWsVBDsiFrE8U,1076
+vrymdor_node-1.1.0.dist-info/METADATA,sha256=lEfBDi_nUW0dNldXZfGddKJ9Jh-c647ldCg_xtMi1lM,4989
+vrymdor_node-1.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+vrymdor_node-1.1.0.dist-info/entry_points.txt,sha256=-N-KATg8_a0MyGBahIalDF2LD5eymDTUNdRItrWbN7o,81
+vrymdor_node-1.1.0.dist-info/top_level.txt,sha256=Vue8oZRFU28dYjLTcgZ0716EUvs7LBsNd7QBs4DDDhM,25
+vrymdor_node-1.1.0.dist-info/RECORD,,

vrymdor_node-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vrymdor_node-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+vrymdor-mcp = vrymdor_mcp:main
+vrymdor-node = vrymdor_mcp:main

vrymdor_node-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vrymnox Systems LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vrymdor_node-1.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+vrymdor_mcp
+vrymnox_node

vrymnox_node.py

@@ -0,0 +1,144 @@
+"""Vrymnox AI Node client for Python apps and agent frameworks (one file; needs only httpx).
+
+    from vrymnox_node import VrymnoxNode
+    node = VrymnoxNode("http://vrymnox-gateway:8080", agent_id="agt_...", agent_secret="vrym_agent_...")
+    node.sanitize("Customer jane@acme.io called")            # -> "Customer [REDACTED:EMAIL] called"
+    node.tool("github", "create_issue", {"title": "Login fails"})
+    node.llm("anthropic", "v1/messages", {"model": "...", "messages": [...]})
+
+    # LangChain: every tool the agent's policy allows, as governed LangChain tools
+    tools = node.langchain_tools()
+    # LlamaIndex: the same, as FunctionTools
+    tools = node.llamaindex_tools()
+
+Every call goes through the gateway's checks (identity, policy, redaction, audit). A refusal raises
+VrymnoxError with a stable `code` (tool_not_allowed, rate_limited, agent_stopped, ...) and `retryable`.
+"""
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any
+
+import httpx
+
+
+class VrymnoxError(Exception):
+    def __init__(self, code: str, message: str, retryable: bool = False, response: dict | None = None) -> None:
+        super().__init__(f"{code}: {message}")
+        self.code, self.message, self.retryable, self.response = code, message, retryable, response or {}
+
+
+class VrymnoxHeld(VrymnoxError):
+    """Your policy held the action, so it did not run. Holds are final; `hold_id` is kept for the audit."""
+
+    def __init__(self, hold_id: str, response: dict) -> None:
+        super().__init__("held_by_policy", "Your policy holds this action, so it did not run.", False, response)
+        self.hold_id = hold_id
+
+
+class VrymnoxNode:
+    def __init__(self, url: str, *, agent_id: str, agent_secret: str, http: httpx.Client | None = None,
+                 timeout: float = 120.0) -> None:
+        self.url, self.agent_id, self._secret = url.rstrip("/"), agent_id, agent_secret
+        # Our own name: Cloudflare's browser check in front of a hosted node can refuse stock library names.
+        self._http = http or httpx.Client(timeout=timeout, headers={"User-Agent": "vrymdor-node-python"})
+        self._token, self._expires = "", 0.0
+
+    # ------------------------------------------------------------ plumbing
+    def _auth(self) -> dict:
+        if time.time() >= self._expires - 60:
+            r = self._http.post(f"{self.url}/v1/token", json={"agent_id": self.agent_id, "agent_secret": self._secret})
+            if r.status_code != 200:
+                raise VrymnoxError("unauthenticated", "The gateway refused this agent's credential.")
+            doc = r.json()
+            self._token, self._expires = doc["access_token"], time.time() + int(doc.get("expires_in", 600))
+        return {"Authorization": f"Bearer {self._token}"}
+
+    def run(self, action: dict, input: Any = None, *, context: dict | None = None, dry_run: bool = False,
+            idempotency_key: str | None = None) -> dict:
+        """The raw NodeRequest call. Returns the NodeResponse; raises on refusal or hold."""
+        body = {"node_version": "1", "action": action, "input": input, "context": context or {},
+                "params": {"dry_run": dry_run}, "idempotency_key": idempotency_key or uuid.uuid4().hex}
+        out = self._http.post(f"{self.url}/v1/node/run", json=body, headers=self._auth()).json()
+        return self._result(out)
+
+    @staticmethod
+    def _result(out: dict) -> dict:
+        if out.get("decision") == "hold":
+            raise VrymnoxHeld(out["hold_id"], out)
+        if not out.get("ok"):
+            err = out.get("error") or {}
+            raise VrymnoxError(err.get("code", "error"), err.get("message", "The action was refused."),
+                               bool(err.get("retryable")), out)
+        return out
+
+    def wait_for(self, hold_id: str, *, timeout: float = 900, every: float = 5) -> dict:
+        """The final answer for a held action. Holds are final, so it answers at once: the action did not run
+        (VrymnoxError held_by_policy). Kept so existing code keeps working."""
+        end = time.time() + timeout
+        while time.time() < end:
+            r = self._http.get(f"{self.url}/v1/node/holds/{hold_id}", headers=self._auth())
+            if r.status_code != 202:
+                return self._result(r.json())
+            time.sleep(every)
+        raise VrymnoxError("held_by_policy", "Your policy holds this action, so it did not run.", False)
+
+    # ------------------------------------------------------------ the four actions
+    def sanitize(self, value: Any) -> Any:
+        return self.run({"type": "sanitize"}, value)["output"]
+
+    def tool(self, upstream: str, tool: str, arguments: dict | None = None, **kw) -> Any:
+        return self.run({"type": "tool", "upstream": upstream, "tool": tool}, arguments or {}, **kw)["output"]
+
+    def llm(self, upstream: str, path: str, body: dict, **kw) -> Any:
+        return self.run({"type": "llm", "upstream": upstream, "path": path}, body, **kw)["output"]
+
+    def webhook(self, upstream: str, payload: Any, **kw) -> Any:
+        return self.run({"type": "webhook", "upstream": upstream}, payload, **kw)["output"]
+
+    # ------------------------------------------------------------ framework adapters
+    def governed_tools(self) -> list[dict]:
+        """The tools this agent may call, from the gateway's MCP tool list (policy decides; nothing is guessed)."""
+        msg = {"jsonrpc": "2.0", "id": 1, "method": "tools/list"}
+        tools = self._http.post(f"{self.url}/mcp", json=msg, headers=self._auth()).json()["result"]["tools"]
+        return [t for t in tools if "__" in t["name"]]
+
+    def _caller(self, name: str):
+        upstream, tool = name.split("__", 1)
+
+        def call(**arguments: Any) -> Any:
+            return self.tool(upstream, tool, arguments)
+        return call
+
+    def langchain_tools(self) -> list:
+        from langchain_core.tools import StructuredTool  # optional dependency
+
+        return [StructuredTool.from_function(func=self._caller(t["name"]), name=t["name"], description=t["description"],
+                                             args_schema=t["inputSchema"]) for t in self.governed_tools()]
+
+    def llamaindex_tools(self) -> list:
+        from llama_index.core.tools import FunctionTool  # optional dependency
+
+        return [FunctionTool.from_defaults(fn=self._caller(t["name"]), name=t["name"], description=t["description"],
+                                           fn_schema=_json_schema_model(t["name"], t.get("inputSchema") or {}))
+                for t in self.governed_tools()]
+
+
+def _json_schema_model(name: str, schema: dict):
+    """A pydantic model that reports the gateway's JSON Schema as is. LlamaIndex reads a tool's arguments from
+    fn_schema; without it the model would only see the caller's generic **arguments. Extra fields are allowed
+    because the gateway, not this model, validates the arguments (tool_schema rule)."""
+    from pydantic import BaseModel, ConfigDict
+
+    published = {"type": "object", "properties": {}, **schema}
+
+    class ToolArguments(BaseModel):
+        model_config = ConfigDict(extra="allow")
+
+        @classmethod
+        def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict:
+            return dict(published)
+
+    ToolArguments.__name__ = ToolArguments.__qualname__ = "".join(p.title() for p in name.split("_") if p) or "Tool"
+    return ToolArguments