chain-insights 0.37.2 → 0.40.0

package/dist/mcp-proxy.cjs

@@ -2,13 +2,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
 const require_version = require("./version-CO9Or_YV.cjs");
 const require_client = require("./client-Ypw9BNbn.cjs");
-const require_tool_visibility = require("./tool-visibility-CyZqYnQA.cjs");
+const require_tool_visibility = require("./tool-visibility-Boxtlbtr.cjs");
 const require_usage_status = require("./usage-status-BdwwgYsu.cjs");
 const require_subscription_status = require("./subscription-status-Cm7LqY_h.cjs");
 const require_capabilities = require("./capabilities-BbAQ4Tfa.cjs");
 const require_action_log = require("./action-log-HniMMF7f.cjs");
+let node_url = require("node:url");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
 let zod = require("zod");
 zod = require_rolldown_runtime.__toESM(zod, 1);
@@ -16,20 +18,367 @@ let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk
 let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 let _modelcontextprotocol_sdk_client_index_js = require("@modelcontextprotocol/sdk/client/index.js");
 let _modelcontextprotocol_sdk_client_streamableHttp_js = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+//#region src/mcp/flows.ts
+/**
+* The money-flow view tools of the local proxy: money_flows and graph_expand.
+*
+* money_flows answers one robinhood address with its most recent senders and
+* receivers: a short text the model reads, and chain-insights.flows.v1 in
+* structuredContent, which the Chain Insights view (ui://chain-insights/view)
+* draws. graph_expand is the same answer for the next page of one address. The
+* view calls it when the investigator clicks an address; its _meta says
+* visibility ["app"], so a host keeps it away from the model.
+*
+* Both tools are composed on the client PC from three anchored graph_query
+* reads (the node, its outgoing FLOWS_TO and its incoming FLOWS_TO, newest
+* first), sent through the proxy's remote client, the same path and payment
+* wrapping a graph_query call takes. Each read is billed as a graph_query.
+* Every argument is checked before the first read, so a refused call reaches
+* no graph endpoint and costs nothing.
+*/
+const FLOWS_SCHEMA = "chain-insights.flows.v1";
+const MONEY_FLOWS_TOOL = "money_flows";
+const GRAPH_EXPAND_TOOL = "graph_expand";
+const FLOWS_NETWORK = "robinhood";
+/** Where a graph_expand page may start on each side, at most. */
+const FLOWS_MAX_OFFSET = 1e4;
+const INVALID_ADDRESS_TEXT = "invalid_address: a full 0x address of 40 hexadecimal characters is needed, for example 0x04911a118f11c75667e4d0dfb8e640af5a353550";
+const OFFSET_TOO_LARGE_TEXT = `invalid_offset: in_offset and out_offset must each be at most ${FLOWS_MAX_OFFSET}`;
+const OFFSET_NEGATIVE_TEXT = "invalid_offset: in_offset and out_offset must each be a whole number, 0 or more";
+const ADDRESS_PATTERN = /^0x[0-9a-f]{40}$/;
+const CODE_PREFIX = /^([a-z][a-z0-9_]*):\s*/;
+/**
+* The address lower-cased, or null when it is not 0x and 40 hexadecimal
+* characters. Only an address that passes is ever written into a read, so the
+* reads can carry it as a literal.
+*/
+function normalizeFlowsAddress(raw) {
+	if (typeof raw !== "string") return null;
+	const address = raw.trim().toLowerCase();
+	return ADDRESS_PATTERN.test(address) ? address : null;
+}
+const NODE_FIELDS = "b.address AS address, b.labels AS labels, b.is_exchange AS is_exchange, b.is_sanctioned AS is_sanctioned, b.is_scam AS is_scam, b.is_victim AS is_victim, b:Pool AS pool, b.total_in_usd AS total_in_usd, b.total_out_usd AS total_out_usd, b.degree_in AS degree_in, b.degree_out AS degree_out";
+const PARTY_FIELDS = NODE_FIELDS + ", f.amount_usd_sum AS usd, f.tx_count AS tx_count, " + "f.first_seen_timestamp AS first_seen, f.last_seen_timestamp AS last_seen";
+const PAGE_ORDER = " ORDER BY f.last_seen_timestamp DESC, b.address";
+/**
+* The three anchored reads of one page. Each side asks for one row more than
+* it shows: the extra row says another page exists.
+*/
+function flowsReadsFor(address, inOffset, outOffset) {
+	const page = (offset) => `${PAGE_ORDER}${offset > 0 ? ` SKIP ${offset}` : ""} LIMIT 13`;
+	return [
+		{
+			id: "node",
+			query: `USE topology MATCH (b:Address {address: '${address}'}) RETURN ${NODE_FIELDS} LIMIT 1`
+		},
+		{
+			id: "out",
+			query: `USE topology MATCH (a:Address {address: '${address}'})-[f:FLOWS_TO]->(b:Address) RETURN ${PARTY_FIELDS}${page(outOffset)}`
+		},
+		{
+			id: "in",
+			query: `USE topology MATCH (b:Address)-[f:FLOWS_TO]->(a:Address {address: '${address}'}) RETURN ${PARTY_FIELDS}${page(inOffset)}`
+		}
+	];
+}
+/** The role word of an address, first match wins. */
+function flowsRole(row) {
+	if (row.is_exchange === true) return "exchange";
+	if (row.is_sanctioned === true) return "sanctioned";
+	if (row.is_scam === true) return "scam";
+	if (row.is_victim === true) return "victim";
+	if (row.pool === true) return "pool";
+	return "other";
+}
+function flowsFloat(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function flowsInt(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function flowsNodeOf(row) {
+	const labels = Array.isArray(row.labels) ? row.labels.filter((label) => typeof label === "string") : [];
+	return {
+		address: typeof row.address === "string" ? row.address : "",
+		role: flowsRole(row),
+		labels,
+		total_in_usd: flowsFloat(row.total_in_usd),
+		total_out_usd: flowsFloat(row.total_out_usd),
+		degree_in: flowsInt(row.degree_in),
+		degree_out: flowsInt(row.degree_out)
+	};
+}
+function assembleFlowView(network, page, senders, receivers, truncated) {
+	const center = flowsNodeOf(page.center);
+	const view = {
+		schema: FLOWS_SCHEMA,
+		network,
+		center: center.address,
+		nodes: [center],
+		edges: [],
+		cursor: {
+			in_offset: page.inOffset + senders.length,
+			out_offset: page.outOffset + receivers.length
+		},
+		truncated
+	};
+	const seen = /* @__PURE__ */ new Set([center.address]);
+	const add = (row, incoming) => {
+		const node = flowsNodeOf(row);
+		if (!seen.has(node.address)) {
+			seen.add(node.address);
+			view.nodes.push(node);
+		}
+		view.edges.push({
+			from: incoming ? node.address : center.address,
+			to: incoming ? center.address : node.address,
+			usd: flowsFloat(row.usd),
+			tx_count: flowsInt(row.tx_count),
+			first_seen_ms: flowsInt(row.first_seen),
+			last_seen_ms: flowsInt(row.last_seen)
+		});
+	};
+	for (const row of senders) add(row, true);
+	for (const row of receivers) add(row, false);
+	return view;
+}
+function fitsFlowBudget(view) {
+	return view.nodes.length <= 60 && JSON.stringify(view).length < 4e4;
+}
+/**
+* flows.v1 from one page: the centre first, then the senders and the
+* receivers, each newest first, at most FLOWS_PER_SIDE a side. When the view
+* data would hold more than FLOWS_MAX_NODES addresses or reach FLOWS_MAX_CHARS
+* characters, the oldest links go first, the view is marked truncated, and the
+* cursor still says where the next page starts.
+*/
+function buildFlowView(network, page) {
+	let truncated = page.senders.length > 12 || page.receivers.length > 12;
+	let senders = page.senders.slice(0, 12);
+	let receivers = page.receivers.slice(0, 12);
+	for (;;) {
+		const view = assembleFlowView(network, page, senders, receivers, truncated);
+		if (fitsFlowBudget(view) || senders.length + receivers.length === 0) return view;
+		truncated = true;
+		if (senders.length >= receivers.length) senders = senders.slice(0, -1);
+		else receivers = receivers.slice(0, -1);
+	}
+}
+function formatFlowsUsd(value) {
+	if (!(value > 0)) return "$0";
+	if (value < .01) return "under $0.01";
+	const whole = Math.floor(value);
+	const cents = Math.round((value - whole) * 100);
+	if (cents === 100) return formatFlowsUsd(whole + 1);
+	return `$${whole.toFixed(0).replace(/\B(?=(\d{3})+(?!\d))/g, ",")}.${String(cents).padStart(2, "0")}`;
+}
+function formatFlowsAge(lastSeenMs, now) {
+	if (lastSeenMs <= 0) return "at an unknown time";
+	const date = new Date(lastSeenMs).toISOString().slice(0, 10);
+	const days = Math.trunc((now.getTime() - lastSeenMs) / 864e5);
+	if (days < 1) return `${date} (today)`;
+	if (days === 1) return `${date} (1 day ago)`;
+	return `${date} (${days} days ago)`;
+}
+/** The role word, with up to three address labels beside it. */
+function roleText(node) {
+	if (!node) return "other";
+	if (node.labels.length === 0) return node.role;
+	return `${node.role} (${node.labels.slice(0, 3).join(", ")})`;
+}
+function sideLines(title, parties) {
+	if (parties.length === 0) return [`${title}, newest first: none.`];
+	const lines = [`${title}, newest first (${parties.length}):`];
+	const perLine = parties.length > 6 ? 2 : 1;
+	for (let start = 0; start < parties.length; start += perLine) lines.push(`- ${parties.slice(start, start + perLine).join("; ")}`);
+	return lines;
+}
+/**
+* The text the model reads: the centre, its role and lifetime totals, then
+* every counterparty of the view with its USD, transaction count and last-seen
+* date and age. At most FLOWS_SUMMARY_MAX_LINES lines.
+*/
+function flowsSummary(view, now) {
+	const nodes = new Map(view.nodes.map((node) => [node.address, node]));
+	const center = nodes.get(view.center);
+	const party = (address, edge) => `${address} ${roleText(nodes.get(address))}, ${formatFlowsUsd(edge.usd)} in ${edge.tx_count} tx, last seen ${formatFlowsAge(edge.last_seen_ms, now)}`;
+	const senders = [];
+	const receivers = [];
+	for (const edge of view.edges) if (edge.to === view.center) senders.push(party(edge.from, edge));
+	else receivers.push(party(edge.to, edge));
+	const lines = [
+		`Money flows of ${view.center} on ${view.network}: ${roleText(center)}; lifetime ${formatFlowsUsd(center?.total_in_usd ?? 0)} in, ${formatFlowsUsd(center?.total_out_usd ?? 0)} out; ${center?.degree_in ?? 0} senders and ${center?.degree_out ?? 0} receivers in the topology graph.`,
+		...sideLines("Recent senders", senders),
+		...sideLines("Recent receivers", receivers)
+	];
+	if (view.truncated) lines.push("More flows exist than shown; the view loads the next page on click.");
+	return lines.slice(0, 20).join("\n");
+}
+function errorResult(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		isError: true
+	};
+}
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function answerText(answer) {
+	return (answer.content ?? []).map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").filter(Boolean).join("\n").trim();
+}
+/**
+* The refusal of a read that did not answer, naming its code first:
+* error_detail.code when the graph endpoint sent its typed refusal, the code
+* its text starts with otherwise, and graph_query_failed when it names none.
+* The view marks the address it was expanding.
+*/
+function refusalText(answer) {
+	const text = answerText(answer);
+	const detail = isRecord$1(answer.structuredContent) ? answer.structuredContent.error_detail : void 0;
+	const detailCode = isRecord$1(detail) && typeof detail.code === "string" ? detail.code : "";
+	const textCode = CODE_PREFIX.exec(text)?.[1] ?? "";
+	const code = detailCode || textCode || "graph_query_failed";
+	const rest = textCode === code ? text.replace(CODE_PREFIX, "") : text;
+	return rest ? `${code}: ${rest}` : `${code}: the graph endpoint refused the read`;
+}
+function rowsOf(answer) {
+	const facts = isRecord$1(answer.structuredContent) ? answer.structuredContent.facts : void 0;
+	const query = isRecord$1(facts) ? facts.query : void 0;
+	const results = isRecord$1(query) ? query.results : void 0;
+	return Array.isArray(results) ? results.filter(isRecord$1) : null;
+}
+function checkNetworkAndAddress(args) {
+	const rawNetwork = typeof args.network === "string" ? args.network.trim().toLowerCase() : "";
+	if (!rawNetwork) return { error: "invalid_network: network is required; pass robinhood" };
+	if (rawNetwork !== "robinhood") return { error: `invalid_network: money flows read the robinhood topology graph only; got "${String(args.network).trim()}"` };
+	const address = normalizeFlowsAddress(args.address);
+	if (!address) return { error: INVALID_ADDRESS_TEXT };
+	return {
+		network: FLOWS_NETWORK,
+		address
+	};
+}
+function checkOffset(value) {
+	if (value === void 0 || value === null) return 0;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) return { error: OFFSET_NEGATIVE_TEXT };
+	if (value > 1e4) return { error: OFFSET_TOO_LARGE_TEXT };
+	return value;
+}
+/**
+* Read and answer one page. The reads run one after another: the node first,
+* so an address the graph does not hold costs one read, not three; then the
+* receivers and the senders. The first read that does not answer ends the call.
+*/
+async function runFlows(deps, network, address, inOffset, outOffset) {
+	const unavailable = deps.unavailable?.();
+	if (unavailable) return errorResult(unavailable);
+	const rows = {};
+	for (const read of flowsReadsFor(address, inOffset, outOffset)) {
+		let answer;
+		try {
+			answer = await deps.graphQuery({
+				network,
+				query: read.query
+			});
+		} catch (err) {
+			return errorResult(deps.describeFailure(err));
+		}
+		if (answer.isError === true) return errorResult(refusalText(answer));
+		const found = rowsOf(answer);
+		if (!found) return errorResult("graph_query_failed: the graph endpoint answered without chain-insights.result.v1 rows");
+		rows[read.id] = found;
+		if (read.id === "node" && found.length === 0) return errorResult(`${address} is not in the ${network} topology graph`);
+	}
+	const view = buildFlowView(network, {
+		center: rows.node?.[0] ?? {},
+		senders: rows.in ?? [],
+		receivers: rows.out ?? [],
+		inOffset,
+		outOffset
+	});
+	return {
+		content: [{
+			type: "text",
+			text: flowsSummary(view, deps.now ? deps.now() : /* @__PURE__ */ new Date())
+		}],
+		structuredContent: view,
+		isError: false
+	};
+}
+/** money_flows {address, network}: the first page of one address. */
+async function handleMoneyFlows(args, deps) {
+	const checked = checkNetworkAndAddress(isRecord$1(args) ? args : {});
+	if ("error" in checked) return errorResult(checked.error);
+	return runFlows(deps, checked.network, checked.address, 0, 0);
+}
+/** graph_expand {network, address, in_offset, out_offset}: the next page of one address. */
+async function handleGraphExpand(args, deps) {
+	const record = isRecord$1(args) ? args : {};
+	const checked = checkNetworkAndAddress(record);
+	if ("error" in checked) return errorResult(checked.error);
+	const inOffset = checkOffset(record.in_offset);
+	if (typeof inOffset !== "number") return errorResult(inOffset.error);
+	const outOffset = checkOffset(record.out_offset);
+	if (typeof outOffset !== "number") return errorResult(outOffset.error);
+	return runFlows(deps, checked.network, checked.address, inOffset, outOffset);
+}
+const MONEY_FLOWS_DESCRIPTION = "Show the most recent money flows around one robinhood address, read from the Chain Insights topology graph: the address with its role and lifetime USD totals, its 12 most recent senders and its 12 most recent receivers, each link with its lifetime USD, transaction count and last-seen time. The answer is a text summary, and an interactive graph in hosts that draw MCP apps. An address not in the graph is an error. Read-only; billed as three graph_query topology reads, or one when the address is not in the graph.";
+const GRAPH_EXPAND_DESCRIPTION = "Load the next page of senders and receivers of one address into an open money-flow view. Called by the view when the investigator clicks an address. Read-only; billed as three graph_query topology reads, nothing when it is refused before a read.";
+/** The line of the server instructions that tells a model what money_flows answers. */
+const MONEY_FLOWS_INSTRUCTION = "Use money_flows to see who sent money to one robinhood address and where it went: its 12 most recent senders and receivers, each with lifetime USD, transaction count and last-seen time.";
+//#endregion
 //#region src/mcp/proxy.ts
 const LOCAL_TOOL_NAMES = /* @__PURE__ */ new Set([
 	"meta_network_capabilities",
 	"meta_usage_status",
 	"meta_subscription_status",
 	"meta_help",
-	"wallet_balance"
+	"wallet_balance",
+	"wallet_topup",
+	MONEY_FLOWS_TOOL,
+	GRAPH_EXPAND_TOOL
 ]);
+const APP_ONLY_LOCAL_TOOL_NAMES = /* @__PURE__ */ new Set([GRAPH_EXPAND_TOOL]);
 const GRAPH_ARRAY_KEYS = [
 	"nodes",
 	"edges",
 	"flows",
 	"edge_anchors"
 ];
+const CLAUDE_VIEW_URI = "ui://chain-insights/view";
+const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+const VIEW_TOOL_META = {
+	ui: { resourceUri: CLAUDE_VIEW_URI },
+	"ui/resourceUri": CLAUDE_VIEW_URI
+};
+const APP_ONLY_TOOL_META = { ui: {
+	resourceUri: CLAUDE_VIEW_URI,
+	visibility: ["app"]
+} };
+const VIEW_RESOURCE_META = { ui: {
+	prefersBorder: false,
+	csp: { resourceDomains: ["https://assets.claude.ai"] }
+} };
+const VIEW_TOOL_ANNOTATIONS = { readOnlyHint: true };
+const CLAUDE_VIEW_FILE = "claude-view.html";
+let claudeViewHtml;
+/**
+* The view file shipped in the package: dist/apps/claude-view.html next to the
+* built proxy, or src/mcp/apps/claude-view.html when run from source. Read once.
+*/
+function readClaudeViewHtml() {
+	if (claudeViewHtml !== void 0) return claudeViewHtml;
+	const here = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	const candidates = [node_path.default.join(here, "apps", CLAUDE_VIEW_FILE), node_path.default.join(here, "..", "src", "mcp", "apps", CLAUDE_VIEW_FILE)];
+	for (const candidate of candidates) try {
+		claudeViewHtml = (0, node_fs.readFileSync)(candidate, "utf8");
+		return claudeViewHtml;
+	} catch {}
+	throw new Error(`The Chain Insights view file ${CLAUDE_VIEW_FILE} is missing from the package`);
+}
 function resolveMcpProxyMode(env = process.env) {
 	const raw = env["CHAIN_INSIGHTS_MCP_PROXY_MODE"]?.trim().toLowerCase();
 	if (!raw || raw === "stateless") return "stateless";
@@ -48,6 +397,10 @@ const KNOWN_PUBLIC_TOOL_DESCRIPTIONS = {
 	graph_query: `Run a read-only GQL/Cypher query through the Chain Insights graph endpoint. ${GRAPH_LAYERS_TEXT} Preserve full addresses exactly.`,
 	graph_query_batch: "Run multiple read-only GQL/Cypher queries through the Chain Insights graph endpoint in one paid batch. Prefer this for related topology/facts reads."
 };
+const KNOWN_PUBLIC_TOOL_TITLES = {
+	graph_query: "Graph Query",
+	graph_query_batch: "Graph Query Batch"
+};
 const FALLBACK_GRAPH_PRIMITIVE_TOOL_NAMES = ["graph_query", "graph_query_batch"];
 const NETWORK_SCHEMA = zod.string().min(1).describe("Network to query. Call meta_network_capabilities first and pass a name GraphRAG advertised. CIA does not pick a default network.");
 const EMPTY_INPUT_SCHEMA = zod.strictObject({});
@@ -56,7 +409,8 @@ const CHAIN_INSIGHTS_WORKFLOW = [
 	"Workflow:",
 	"1. Do not call investigation tools until required arguments are known. Network is required; use meta_network_capabilities to check supported networks and available tools, or ask the user if missing.",
 	"2. Use aml_address_risk for single-address enrichment. Use graph_query(_batch) for graph-level questions that aml_address_risk does not answer.",
-	"3. Preserve tool summaries and structured facts as returned. Keep full blockchain addresses intact."
+	`3. ${MONEY_FLOWS_INSTRUCTION}`,
+	"4. Preserve tool summaries and structured facts as returned. Keep full blockchain addresses intact."
 ].join("\n");
 const GRAPH_SCHEMA_HINTS = [
 	"Graph query hints:",
@@ -65,10 +419,10 @@ const GRAPH_SCHEMA_HINTS = [
 	"- The graph is address-grain. The only topology money node label is Address, keyed by the raw chain-native H160 address on EVM networks, for example 0x1874a43d7c6d888f9eda3d22a3a49704e3cadb24. The network value on Address nodes matches the tool argument. There is no separate identity key.",
 	"- Address nodes carry address, network, labels, and the role flags is_exchange, is_scam, is_victim and is_sanctioned. (:Address)-[:LINKED]-(:Address) is an undirected ownership-overlay edge (basis derived/associated, plus confidence, source_event, declared_owner, owner_state) asserting the two addresses are controlled by the same actor. LINKED is served on the topology graph only. Enumerate LINKED neighbors with MATCH (a:Address {address: $addr})-[l:LINKED]-(b:Address) RETURN b.address, b.network, l.basis, l.confidence.",
 	"- Labels hold role words, never detector names: Exchange (plus the exchange name), Scam, Victim and Sanctioned (plus the entity name). Each role is also a node label and a flag on the Address: :Exchange and is_exchange follow the exchange label, :Scam and is_scam the risk label, :Victim and is_victim the protection label, :Sanctioned and is_sanctioned the sanctioned label. Each flag is present only when true and absent otherwise, never false: test IS NOT NULL or IS NULL, not = false. A withdrawn label removes its node label and its flag.",
-	"- Address nodes also carry a risk verdict (risk_score float, risk_level string) plus base activity rollups: degree_in/degree_out/degree_total (distinct counterparty addresses), tx_in_count/tx_out_count/tx_total_count, total_in_usd/total_out_usd/total_volume_usd, net_flow_usd (in minus out; positive = net receiver) — all computed from external flows only — and first_activity_timestamp/last_activity_timestamp/activity_span_days, which include all flows (self-loops included). FLOWS_TO edges carry exactly tx_count, amount_usd_sum (total money flow, token and native value merged), first_seen_timestamp, last_seen_timestamp. Lifetime aggregates are the only serving window. Averages are computed inline (amount_usd_sum / toFloat(tx_count)). tx_count counts token and native transfers plus internal native transfers (a contract sending ETH during a call), and amount_usd_sum prices them all. USE facts TRANSFER lists the first group only, so a pair can have tx_count above 0 and no TRANSFER row, and no MCP read lists internal transfers yet. An address-only TRANSFER read covers a recent window (90 days today) and a link covers all time: bound the read with block_date to read further back. For a pair with token or native transfers, a transaction anchor resolves through USE facts: MATCH (a:Address {address: $from})-[t:TRANSFER]->(b:Address {address: $to}) RETURN t.tx_id ORDER BY t.block_timestamp ASC LIMIT 1.",
+	"- Address nodes also carry a risk verdict (risk_score float, risk_level string) plus base activity rollups: degree_in/degree_out/degree_total (distinct counterparty addresses), tx_in_count/tx_out_count/tx_total_count, total_in_usd/total_out_usd/total_volume_usd, net_flow_usd (in minus out; positive = net receiver) — all computed from external flows only — and first_activity_timestamp/last_activity_timestamp/activity_span_days, which include all flows (self-loops included). FLOWS_TO edges carry exactly tx_count, amount_usd_sum (total money flow, token and native value merged), first_seen_timestamp, last_seen_timestamp. Lifetime aggregates are the only serving window. Averages are computed inline (amount_usd_sum / toFloat(tx_count)). tx_count counts token and native transfers plus internal native transfers (a contract sending ETH during a call), and amount_usd_sum prices them all. USE facts TRANSFER lists the first group only, so a pair can have tx_count above 0 and no TRANSFER row, and no MCP read lists internal transfers yet. A link covers all time and a USE facts read covers one day: read the transfers of a pair one day at a time. For a pair with token or native transfers, a transaction anchor resolves through USE facts, on the UTC day of the first_seen_timestamp or last_seen_timestamp of the link: MATCH (a:Address {address: $from})-[t:TRANSFER]->(b:Address {address: $to}) WHERE t.block_date = \"YYYY-MM-DD\" RETURN t.tx_id, t.block_timestamp LIMIT 1.",
 	"- For actor-level exposure (AC11), UNION FLOWS_TO and SWAPPED reachability over one visible LINKED hop instead of expanding through the LINKED edge itself: MATCH (a:Address {address: $addr})-[:LINKED]-(owned:Address)-[r:FLOWS_TO|SWAPPED]-(b:Address) WHERE NOT a:Pool AND NOT owned:Pool AND owned.address <> b.address AND a.address <> b.address RETURN owned.address, b.address, type(r), coalesce(r.amount_usd_sum, r.bought_usd).",
 	"- The risk verdict lives on topology nodes (risk_score float, risk_level string). An absent risk_score means UNSCORED: the model gave the address no verdict, which is no signal and never low risk. Labels and per-label risk also live on the address node: the labels array plus three parallel lists, label_risk_labels, label_risk_levels and label_risk_updated_timestamps, where entry i of each list is one label row. USE facts serves bounded single-event rows (TRANSFER, SWAP, LIQUIDITY_ADD, LIQUIDITY_REMOVE and BRIDGE_CROSSING edges) only; lifetime address metrics (degrees, totals, activity window) are node properties on USE topology.",
-	"- (from:Address)-[t:TRANSFER]->(to:Address) on USE facts returns individual transfer rows, not aggregates, with properties amount, amount_usd, asset_symbol, asset_contract, tx_id, block_height, block_timestamp, event_index, edge_index, price_usd, and price_missing. Every TRANSFER query — row-select or count()/sum() aggregate — requires an indexed predicate: address equality on either endpoint (for example {address: \"...\"} on from or to), a WHERE t.tx_id = \"...\" equality (on EVM networks tx_id is the 0x transaction hash), or a bare WHERE t.block_date = \"YYYY-MM-DD\" bound, which t.block_timestamp bounds in epoch milliseconds may narrow to a time window; a bare LIMIT with no indexed predicate is rejected, since facts_transfers_view is a full transfer-history table, not a small per-address dimension view.",
+	"- (from:Address)-[t:TRANSFER]->(to:Address) on USE facts returns individual transfer rows, not aggregates, with properties amount, amount_usd, asset_symbol, asset_contract, tx_id, block_height, block_timestamp, event_index, edge_index, price_usd, and price_missing. A facts read names an address pair with one day, or one tx_id, whether it is a TRANSFER row-select or a count()/sum() aggregate: both endpoint addresses as {address: \"...\"} on from and to, with WHERE t.block_date = \"YYYY-MM-DD\", or WHERE t.tx_id = \"...\" on its own (on EVM networks tx_id is the 0x transaction hash). t.block_timestamp bounds in epoch milliseconds may narrow the day to a time window. One address, a day alone, a window of days, a block range or a bare LIMIT is not enough, and a facts read has one relationship and takes no ORDER BY.",
 	"- Facts graph labels include Address; the TRANSFER, SWAP, LIQUIDITY_ADD, LIQUIDITY_REMOVE and BRIDGE_CROSSING relationships each connect two Address nodes. Facts address keys match topology address values exactly.",
 	"- Topology relationships include FLOWS_TO, SWAPPED, OPERATED_BY, LINKED, and RISK_PROXIMITY between Address nodes, ADDED_LIQUIDITY and REMOVED_LIQUIDITY to and from Pool nodes, and BRIDGED to and from Chain nodes.",
 	"- (:Address)-[:OPERATED_BY]->(:Address) is the directed owner-to-operator edge: the transaction sender that moved the owner's tokens (ERC-20/721), or the event operator (ERC-1155); not the approved spender. Aggregate properties: tx_count, amount_usd_sum, first_seen_timestamp, last_seen_timestamp, and optional token_standard (ERC20/ERC721/ERC1155; absent when the pair is mixed-standard). Valuation fields: valuation_tracked_count, valued_count and the reason counters missing_valuation_price_count, unknown_quantity_count, unrepresentable_quantity_count and usd_range_count. valuation_complete is true when valued_count equals valuation_tracked_count, valuation_coverage_ratio is valued_count divided by valuation_tracked_count, and amount_usd_sum counts a transfer with no USD value as 0, so it is a floor unless valuation_complete is true. One edge per owner/operator pair; direct transfers with no operator create none; an owner never operates for itself. Topology-only, and a topology fact — not a risk label. Probe: MATCH (owner:Address)-[operation:OPERATED_BY]->(operator:Address {address: $addr}) RETURN owner.address AS owner, operation.tx_count AS tx_count ORDER BY operation.tx_count DESC LIMIT 10.",
@@ -77,9 +431,10 @@ const GRAPH_SCHEMA_HINTS = [
 	"- Pool is a second label on an Address: the pool of a swap route or liquidity event, with liquidity_added_usd, liquidity_removed_usd, liquidity_net_usd, provider_count and receiver_count. (:Address)-[:ADDED_LIQUIDITY]->(:Pool) and (:Pool)-[:REMOVED_LIQUIDITY]->(:Address) join named providers and receivers to the pool, with event_count, totals_raw, usd, unpriced_count, first_seen_height and last_seen_height; REMOVED_LIQUIDITY adds fees_raw, receiver_added_usd (USD the receiver itself added to the same pool) and receiver_provided. A receiver's profit from a pool is usd minus receiver_added_usd: receiver_provided false is a drain by a stranger, true with a large profit is the creator's rug pull.",
 	"- (:Address)-[:BRIDGED]->(:Chain) is outbound bridge use and (:Chain)-[:BRIDGED]->(:Address) inbound, with kinds, events, totals_raw, first_height, last_height and last_bridge_event_id. A Chain node (network, address) is the remote bridge endpoint, never an Address, so no FLOWS_TO walk passes through it.",
 	"- Pool trace rule, for every trace: 1. Enter a `:Pool` on any edge. 2. Leave a `:Pool` only on `REMOVED_LIQUIDITY`, to the address the liquidity was paid to. 3. Never leave a `:Pool` on `FLOWS_TO`. 4. Across a swap, follow `SWAPPED` from payer to recipient, between two different addresses. Do not walk through the pool. Rug-pull probe: MATCH (victim:Address {address: $addr})-[paid:FLOWS_TO]->(pool:Pool)-[removal:REMOVED_LIQUIDITY]->(receiver:Address) WHERE NOT victim:Pool AND receiver.address <> victim.address RETURN pool.address AS pool_address, receiver.address AS receiver_address, removal.usd AS removed_usd, removal.receiver_added_usd AS receiver_added_usd, removal.receiver_provided AS receiver_provided LIMIT 25.",
-	"- USE facts serves the single events. (payer:Address)-[s:SWAP]->(recipient:Address) is one row per swap route, self swaps included, with strength, reason, route_id, pools, families and the sold_ and bought_ asset, amount and usd columns. (provider:Address)-[:LIQUIDITY_ADD]->(pool:Address) and (pool:Address)-[:LIQUIDITY_REMOVE]->(receiver:Address) are one row per liquidity event, with party_state and evidence_state. SWAP and LIQUIDITY_* need an address equality on either endpoint or a tx_id equality. (sender:Address)-[c:BRIDGE_CROSSING]->(recipient:Address) is one row per bridge event and needs a bare block_date bound or a tx_id equality. USD comes from the daily price services, never from a swap: with no price, USD is empty and the matching price_missing column is true (price_missing on TRANSFER, sold_price_missing and bought_price_missing on SWAP, amount0_price_missing and amount1_price_missing on LIQUIDITY_*). block_timestamp on TRANSFER, SWAP and LIQUIDITY_* rows is epoch milliseconds, in filters and in results; BRIDGE_CROSSING has none.",
+	"- USE facts serves the single events. (payer:Address)-[s:SWAP]->(recipient:Address) is one row per swap route, self swaps included, with strength, reason, route_id, pools, families and the sold_ and bought_ asset, amount and usd columns. (provider:Address)-[:LIQUIDITY_ADD]->(pool:Address) and (pool:Address)-[:LIQUIDITY_REMOVE]->(receiver:Address) are one row per liquidity event, with party_state and evidence_state. (sender:Address)-[c:BRIDGE_CROSSING]->(recipient:Address) is one row per bridge event. SWAP, LIQUIDITY_* and BRIDGE_CROSSING take the same rule as TRANSFER: an address pair with one day, or one tx_id. USD comes from the daily price services, never from a swap: with no price, USD is empty and the matching price_missing column is true (price_missing on TRANSFER, sold_price_missing and bought_price_missing on SWAP, amount0_price_missing and amount1_price_missing on LIQUIDITY_*). block_timestamp on TRANSFER, SWAP and LIQUIDITY_* rows is epoch milliseconds, in filters and in results; BRIDGE_CROSSING has none.",
+	"- Temporary, until graph server issue 1121 is fixed. Do not return, filter or order by pools in a USE facts SWAP read. Every such read fails at the warehouse query memory limit with facts query could not be completed: by address, by day and by tx_id. Only pools is built by the failing part of the warehouse view. pool_keys and families come from the main read. Read SWAP rows by tx_id, or by the payer, the recipient and one day, and leave pools out. For the pools of a swap, read SWAPPED.pools on USE topology, anchored on the payer or the recipient. SWAPPED has one link per payer, recipient, sold_asset and bought_asset, so its pools cover every route on the link, not one route.",
 	"- Traversal rule: for BFS, fixed-hop fallback, shortest-path, or manual FLOWS_TO traversal, exchange hot wallets are terminal endpoints only. Do not expand from, through, or classify exchange nodes as deposit, suspect, or intermediate candidates; filter every non-terminal node with is_exchange IS NULL. is_exchange is absent unless true, so a labelled node with no is_exchange is walked through, and is_scam, is_victim and is_sanctioned do not end a walk. At a Pool, follow the pool trace rule above.",
-	"- Pool guard: a trace walks FLOWS_TO and SWAPPED, so it crosses a swap from payer to recipient without passing through the pool. A walk may end at a Pool, but never starts at one or passes through one: its start and every address in its middle stay off a Pool. A fixed-hop walk adds WHERE NOT src:Pool AND NOT mid:Pool, each its own AND term, never inside an OR. A quantified or shortest-path walk puts the guards inside the path pattern, on the start and on up to 4 guarded hops before one last hop: MATCH p = SHORTEST 1 (a:Address {address: $from} WHERE NOT a:Pool) (()-[:FLOWS_TO|SWAPPED]-(via:Address) WHERE NOT via:Pool){0,4} ()-[:FLOWS_TO|SWAPPED]-(b:Address {address: $to}) RETURN [n IN nodes(p) | n.address] AS route. ANY SHORTEST and ALL SHORTEST take the same pattern. An open target from one address: MATCH SHORTEST 1 (a:Address {address: $addr} WHERE NOT a:Pool) (()-[:FLOWS_TO|SWAPPED]-(via:Address) WHERE NOT via:Pool){0,4} ()-[:FLOWS_TO|SWAPPED]-(b:Address) RETURN b.address LIMIT 50. Use these shapes as written, changing only the addresses and the RETURN. A WHERE placed after a SHORTEST pattern runs after the shortest route is chosen, so it drops a route that crosses a pool instead of finding the route that avoids it.",
+	"- Pool guard: a trace walks FLOWS_TO and SWAPPED, so it crosses a swap from payer to recipient without passing through the pool. A walk may end at a Pool, but never starts at one or passes through one: its start and every address in its middle stay off a Pool. A fixed-hop walk adds WHERE NOT src:Pool AND NOT mid:Pool, each its own AND term, never inside an OR. A quantified or shortest-path walk puts the guards inside the path pattern, on the start and on up to 4 guarded hops before one last hop: MATCH p = SHORTEST 1 (a:Address {address: $from} WHERE NOT a:Pool) (()-[:FLOWS_TO|SWAPPED]-(via:Address) WHERE NOT via:Pool){0,4} ()-[:FLOWS_TO|SWAPPED]-(b:Address {address: $to}) RETURN [n IN nodes(p) | n.address] AS route LIMIT 5. ANY SHORTEST takes the same pattern. A route search asks for one path. An open target from one address: MATCH SHORTEST 1 (a:Address {address: $addr} WHERE NOT a:Pool) (()-[:FLOWS_TO|SWAPPED]-(via:Address) WHERE NOT via:Pool){0,4} ()-[:FLOWS_TO|SWAPPED]-(b:Address) RETURN b.address LIMIT 50. Use these shapes as written, changing only the addresses and the RETURN. A WHERE placed after a SHORTEST pattern runs after the shortest route is chosen, so it drops a route that crosses a pool instead of finding the route that avoids it.",
 	"- Start schema discovery with endpoint-safe property reads: MATCH (n:Address) WHERE n.address IS NOT NULL RETURN n.address AS address, n.network AS network, n.labels AS labels, n.risk_score AS risk_score, n.risk_level AS risk_level LIMIT 20",
 	"- Relationship discovery: MATCH (:Address)-[r:FLOWS_TO]->(:Address) RETURN r.amount_usd_sum AS amount_usd_sum, r.tx_count AS tx_count LIMIT 20",
 	"- Anchor every topology read that filters on a link property: put an address in its pattern. Without one, a read starts from every link of the type it names, and you should not count on the filter to narrow that: WHERE x.strength = 'swap' on SWAPPED checks every SWAPPED link, LIMIT stops the read only after enough rows match, and a filter that matches few or none can run to the 60 s topology limit and fail with query_timeout. Example: MATCH (a:Address {address: $addr})-[x:SWAPPED]->(b:Address) WHERE x.swap_count >= 2 RETURN b.address, x.swap_count LIMIT 25. Pick an address with few links: degree_out and degree_in are a rough guide, because they count neighbours, not links, and an address with hundreds of thousands of neighbours can fail the same way. Discovery probes with LIMIT and no filter stay valid. The queries of one batch share a 100 s budget; USE facts queries stop at 30 s.",
@@ -96,6 +451,7 @@ const SERVER_INSTRUCTIONS = [
 const STATELESS_SERVER_INSTRUCTIONS = [
 	"Chain Insights is running as a stateless AML proxy for a host application.",
 	"Use meta_network_capabilities first when network support is unknown, then call aml_address_risk, graph_query, or graph_query_batch as needed.",
+	MONEY_FLOWS_INSTRUCTION,
 	"Use wallet_balance to inspect the local payment wallet when payment setup is needed.",
 	GRAPH_SCHEMA_HINTS,
 	"Presentation rules: preserve tool summaries as returned; never truncate blockchain addresses or identity_resolution audit mappings."
@@ -134,6 +490,17 @@ function fallbackGraphPrimitiveTools() {
 * server (subscription_status). Returns null — never throws — when no wallet
 * is configured; callers degrade to an unavailable-shape result.
 */
+/**
+* Local payment wallet address for the top-up view: null when no wallet file
+* exists, and an error when the file exists but cannot be read. Reads the
+* address only; nothing is signed or sent.
+*/
+async function localTopupWalletAddress() {
+	const { isWalletConfigured } = await Promise.resolve().then(() => require("./wallet-B3hAr70M.cjs")).then((n) => n.wallet_exports);
+	if (!await isWalletConfigured()) return null;
+	const { getWalletAccount } = await Promise.resolve().then(() => require("./tools-BHfphgy9.cjs")).then((n) => n.tools_exports);
+	return (await getWalletAccount()).address;
+}
 async function localSubscriptionWalletAddress() {
 	try {
 		const { getWalletAccount } = await Promise.resolve().then(() => require("./tools-BHfphgy9.cjs")).then((n) => n.tools_exports);
@@ -338,6 +705,17 @@ function knownPublicToolAnnotations(toolName) {
 		openWorldHint: true
 	};
 }
+/**
+* The text a call to the graph endpoint answers with when it throws: payment
+* guidance for a payment failure, the error otherwise. Shared by every proxied
+* tool and by the money-flow reads.
+*/
+function remoteCallFailureText(toolName, err) {
+	if (err instanceof require_client.PaymentRequiredError) return err.message;
+	const msg = err.message ?? String(err);
+	if (/\b402\b/.test(msg) || msg.toLowerCase().includes("payment")) return `Payment required for ${toolName}. This tool costs USDC on Base via x402 micropayments. Next steps: run \`cia wallet ready\` to check funding and finish one-time payment setup, run \`cia wallet topup\` if it says the wallet needs USDC, or \`cia access-key set <key>\` if you have been given test access.`;
+	return `MCP call failed: ${msg}`;
+}
 function promptResult(text, description) {
 	return {
 		description,
@@ -445,8 +823,6 @@ function sanitizeStructuredValue(value) {
 function sanitizeRemoteMeta(metaValue) {
 	if (!metaValue || typeof metaValue !== "object" || Array.isArray(metaValue)) return void 0;
 	const meta = { ...metaValue };
-	delete meta.ui;
-	delete meta["ui/resourceUri"];
 	const chainInsights = meta.chainInsights;
 	if (chainInsights && typeof chainInsights === "object" && !Array.isArray(chainInsights)) {
 		const { graph: _graph, ...withoutGraph } = chainInsights;
@@ -455,10 +831,13 @@ function sanitizeRemoteMeta(metaValue) {
 	}
 	return Object.keys(meta).length > 0 ? meta : void 0;
 }
-function normalizeRemoteToolResult(result) {
+function stripsGraphPayload(toolName) {
+	return toolName.startsWith("aml_");
+}
+function normalizeRemoteToolResult(toolName, result) {
 	return {
 		content: result.content ?? [],
-		structuredContent: sanitizeStructuredContentForGraphPayload(result.structuredContent),
+		structuredContent: stripsGraphPayload(toolName) ? sanitizeStructuredContentForGraphPayload(result.structuredContent) : result.structuredContent,
 		_meta: sanitizeRemoteMeta(result._meta),
 		isError: result.isError
 	};
@@ -493,7 +872,7 @@ function jsonTextResult(structuredContent) {
 * All diagnostic output goes to console.error() or process.stderr.write().
 */
 async function createProxy() {
-	const { loadConfig } = await Promise.resolve().then(() => require("./config-B542AM4w.cjs")).then((n) => n.config_exports);
+	const { loadConfig } = await Promise.resolve().then(() => require("./config-CPUhkz0Z.cjs")).then((n) => n.config_exports);
 	const { activeDataDir, findActiveWorkspace } = await Promise.resolve().then(() => require("./active-Bc13hJIm.cjs")).then((n) => n.active_exports);
 	const { createConfiguredGraphMcpFetch, resolveGraphMcpEndpoint } = await Promise.resolve().then(() => require("./client-Ypw9BNbn.cjs")).then((n) => n.client_exports);
 	const { loadSchema, saveSchema } = await Promise.resolve().then(() => require("./schema-cache-n7Gbhvsj.cjs"));
@@ -629,6 +1008,7 @@ async function createProxy() {
 		title: "Usage Status",
 		description: KNOWN_PUBLIC_TOOL_DESCRIPTIONS.meta_usage_status,
 		inputSchema: EMPTY_INPUT_SCHEMA,
+		_meta: VIEW_TOOL_META,
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
@@ -676,6 +1056,7 @@ async function createProxy() {
 		title: "Subscription Status",
 		description: KNOWN_PUBLIC_TOOL_DESCRIPTIONS.meta_subscription_status,
 		inputSchema: EMPTY_INPUT_SCHEMA,
+		_meta: VIEW_TOOL_META,
 		annotations: {
 			readOnlyHint: true,
 			destructiveHint: false,
@@ -770,7 +1151,7 @@ async function createProxy() {
 				}],
 				isError: true
 			};
-			const { runAmlAddressRisk } = await Promise.resolve().then(() => require("./public-tools-DWONw7kZ.cjs"));
+			const { runAmlAddressRisk } = await Promise.resolve().then(() => require("./public-tools-3yTC17cA.cjs"));
 			const result = await runAmlAddressRisk(remoteClient, {
 				address,
 				network,
@@ -802,6 +1183,39 @@ async function createProxy() {
 			};
 		}
 	});
+	const flowsDependencies = {
+		graphQuery: async (args) => {
+			const options = remoteToolRequestOptions("graph_query");
+			return await remoteClient.callTool({
+				name: "graph_query",
+				arguments: args
+			}, void 0, options);
+		},
+		describeFailure: (err) => remoteCallFailureText("graph_query", err),
+		unavailable: () => remoteConnected ? void 0 : `${remoteUnavailableMessage ?? `Chain Insights Graph is not connected at ${graphMcpEndpoint}`}. Restart the Chain Insights MCP proxy after the endpoint is reachable.`
+	};
+	server.registerTool(MONEY_FLOWS_TOOL, {
+		title: "Money flows",
+		description: MONEY_FLOWS_DESCRIPTION,
+		inputSchema: {
+			address: zod.string().describe("One robinhood address: 0x and 40 hexadecimal characters."),
+			network: zod.string().describe("The network. Only robinhood is served.")
+		},
+		annotations: VIEW_TOOL_ANNOTATIONS,
+		_meta: VIEW_TOOL_META
+	}, async (args) => handleMoneyFlows(args, flowsDependencies));
+	server.registerTool(GRAPH_EXPAND_TOOL, {
+		title: "Expand a money-flow node",
+		description: GRAPH_EXPAND_DESCRIPTION,
+		inputSchema: {
+			network: zod.string(),
+			address: zod.string(),
+			in_offset: zod.number().int().min(0).max(FLOWS_MAX_OFFSET).optional(),
+			out_offset: zod.number().int().min(0).max(FLOWS_MAX_OFFSET).optional()
+		},
+		annotations: VIEW_TOOL_ANNOTATIONS,
+		_meta: APP_ONLY_TOOL_META
+	}, async (args) => handleGraphExpand(args, flowsDependencies));
 	server.registerTool("meta_help", {
 		title: "Chain Insights Help",
 		description: KNOWN_PUBLIC_TOOL_DESCRIPTIONS.meta_help,
@@ -827,6 +1241,7 @@ async function createProxy() {
 				"- aml_address_risk: screen one blockchain address; optionally compare it with another address.",
 				"- graph_query: run read-only GQL/Cypher through the universal graph endpoint. Use USE topology or USE facts.",
 				"- graph_query_batch: run related read-only graph-language queries through one paid graph call.",
+				"- money_flows: show the most recent senders and receivers of one robinhood address, with an interactive graph in hosts that draw MCP apps.",
 				"",
 				"Wallet tools:",
 				"- wallet_balance: show the local payment wallet address, payment network, token, and amount.",
@@ -840,7 +1255,8 @@ async function createProxy() {
 				"- meta_subscription_status: check the caller CIA subscription window end, daily allowance, consumption, and tier.",
 				"- aml_address_risk: screen one blockchain address; optionally compare it with another address.",
 				"- graph_query: run read-only GQL/Cypher through the universal graph endpoint. Use USE topology or USE facts.",
-				"- graph_query_batch: run related read-only graph-language queries through one paid graph call."
+				"- graph_query_batch: run related read-only graph-language queries through one paid graph call.",
+				"- money_flows: show the most recent senders and receivers of one robinhood address, with an interactive graph in hosts that draw MCP apps."
 			].join("\n")
 		}],
 		isError: false
@@ -848,6 +1264,7 @@ async function createProxy() {
 	for (const tool of tools ?? []) {
 		if (require_tool_visibility.HIDDEN_REMOTE_TOOL_NAMES.has(tool.name)) continue;
 		if (LOCAL_TOOL_NAMES.has(tool.name)) continue;
+		if (require_tool_visibility.isAppOnlyTool(tool)) continue;
 		const inputSchema = knownPublicToolInputSchema(tool.name) ?? zod.object({}).passthrough();
 		const handler = async (args) => {
 			try {
@@ -872,43 +1289,48 @@ async function createProxy() {
 					arguments: normalizedArgs
 				};
 				const requestOptions = remoteToolRequestOptions(tool.name);
-				return normalizeRemoteToolResult(requestOptions ? await remoteClient.callTool(request, void 0, requestOptions) : await remoteClient.callTool(request));
+				const result = requestOptions ? await remoteClient.callTool(request, void 0, requestOptions) : await remoteClient.callTool(request);
+				return normalizeRemoteToolResult(tool.name, result);
 			} catch (err) {
-				if (err instanceof require_client.PaymentRequiredError) return {
-					content: [{
-						type: "text",
-						text: err.message
-					}],
-					isError: true
-				};
-				const msg = err.message ?? String(err);
-				if (/\b402\b/.test(msg) || msg.toLowerCase().includes("payment")) return {
-					content: [{
-						type: "text",
-						text: `Payment required for ${tool.name}. This tool costs USDC on Base via x402 micropayments. Next steps: run \`cia wallet ready\` to check funding and finish one-time payment setup, run \`cia wallet topup\` if it says the wallet needs USDC, or \`cia access-key set <key>\` if you have been given test access.`
-					}],
-					isError: true
-				};
 				return {
 					content: [{
 						type: "text",
-						text: `MCP call failed: ${msg}`
+						text: remoteCallFailureText(tool.name, err)
 					}],
 					isError: true
 				};
 			}
 		};
+		const annotations = knownPublicToolAnnotations(tool.name);
+		const drawsView = tool.name === "graph_query";
 		const toolConfig = {
-			title: tool.title,
+			title: tool.title ?? KNOWN_PUBLIC_TOOL_TITLES[tool.name],
 			description: claudeFacingToolDescription(tool),
 			inputSchema,
-			...knownPublicToolAnnotations(tool.name) ? { annotations: knownPublicToolAnnotations(tool.name) } : {}
+			...annotations ? { annotations } : {},
+			...drawsView ? { _meta: VIEW_TOOL_META } : {}
 		};
 		server.registerTool(tool.name, toolConfig, handler);
 	}
+	const { registerTopupView, TOPUP_VIEW_URI } = await Promise.resolve().then(() => require("./topup-server-Bh7MlzRt.cjs")).then((n) => n.topup_server_exports);
+	await registerTopupView(server, { walletAddress: localTopupWalletAddress });
+	server.registerResource("Chain Insights view", CLAUDE_VIEW_URI, {
+		title: "Chain Insights view",
+		description: "The Chain Insights view for hosts that draw MCP apps: money flows, query results and balance, in light and dark.",
+		mimeType: MCP_APP_MIME_TYPE,
+		_meta: VIEW_RESOURCE_META
+	}, async () => ({ contents: [{
+		uri: CLAUDE_VIEW_URI,
+		mimeType: MCP_APP_MIME_TYPE,
+		text: readClaudeViewHtml(),
+		_meta: VIEW_RESOURCE_META
+	}] }));
 	const transport = new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
 	await server.connect(transport);
-	await logger.info("proxy.ready", { tools: [...LOCAL_TOOL_NAMES, ...(tools ?? []).map((tool) => tool.name).filter((name) => !require_tool_visibility.HIDDEN_REMOTE_TOOL_NAMES.has(name) && !LOCAL_TOOL_NAMES.has(name))].length });
+	await logger.info("proxy.ready", {
+		tools: [...[...LOCAL_TOOL_NAMES].filter((name) => !APP_ONLY_LOCAL_TOOL_NAMES.has(name)), ...(tools ?? []).filter((tool) => !require_tool_visibility.isAppOnlyTool(tool)).map((tool) => tool.name).filter((name) => !require_tool_visibility.HIDDEN_REMOTE_TOOL_NAMES.has(name) && !LOCAL_TOOL_NAMES.has(name))].length,
+		ui_resources: [CLAUDE_VIEW_URI, TOPUP_VIEW_URI]
+	});
 	const shutdown = async () => {
 		await logger.info("proxy.shutdown");
 		transport.close();
@@ -926,6 +1348,9 @@ if (process.argv[1] && require("url").pathToFileURL(__filename).href.includes(pr
 	process.exit(1);
 });
 //#endregion
+exports.CLAUDE_VIEW_URI = CLAUDE_VIEW_URI;
+exports.MCP_APP_MIME_TYPE = MCP_APP_MIME_TYPE;
 exports.createProxy = createProxy;
 exports.knownPublicToolInputSchema = knownPublicToolInputSchema;
+exports.readClaudeViewHtml = readClaudeViewHtml;
 exports.resolveMcpProxyMode = resolveMcpProxyMode;