@tangle-network/hub-sdk 1.0.3 → 1.0.5

package/dist/mcp/index.d.ts

@@ -0,0 +1,119 @@
+import { t as HubClient } from "../client-BH3gTLjN.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { Hono } from "hono";
+import { AgentProfile, AgentProfileConnection, AgentProfileMcpServer } from "@tangle-network/agent-interface";
+
+//#region src/mcp/tools.d.ts
+type HubMcpToolDescriptor = {
+  name: string;
+  path: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+};
+type HubMcpToolResult = {
+  content: Array<{
+    type: "text";
+    text: string;
+  }>;
+  isError?: boolean;
+  /**
+   * Machine-readable error detail for a failed call (MCP `structuredContent`).
+   * Carries the hub error `code` and `details` (e.g. the `approval` object with
+   * `id`/`connectionId` for a `HUB_APPROVAL_REQUIRED` gate) so consumers can act
+   * programmatically — the flattened `content` text alone drops that structure.
+   */
+  structuredContent?: Record<string, unknown>;
+};
+//#endregion
+//#region src/mcp/bridge.d.ts
+interface HubMcpBridgeClient {
+  listTools(): Promise<HubMcpToolDescriptor[]>;
+  callTool(name: string, args: unknown): Promise<HubMcpToolResult>;
+}
+declare class HttpHubMcpBridgeClient implements HubMcpBridgeClient {
+  private readonly endpoint;
+  constructor(endpoint: string);
+  listTools(): Promise<HubMcpToolDescriptor[]>;
+  callTool(name: string, args: unknown): Promise<HubMcpToolResult>;
+}
+declare function createHubMcpBridgeServer(client: HubMcpBridgeClient): Server;
+//#endregion
+//#region src/mcp/profile.d.ts
+/** Keep authored identity separate from runtime-only grant materialization. */
+declare function lowerProfileConnections(profile: AgentProfile | undefined, runtimeMcp: Record<string, AgentProfileMcpServer>): {
+  profile?: AgentProfile;
+  workspaceProfile?: AgentProfile;
+};
+//#endregion
+//#region src/mcp/scope.d.ts
+type HubMcpAuthRetry = <T>(operation: () => Promise<T>) => Promise<T>;
+interface HubMcpScopeOptions {
+  hash(value: object | string): string;
+  withAuthRetry?: HubMcpAuthRetry;
+}
+/** Opaque grants owned by one embedded host; close revokes only this scope. */
+declare class HubMcpScope {
+  private readonly options;
+  private readonly grants;
+  private closed;
+  private readonly withAuthRetry;
+  constructor(options: HubMcpScopeOptions);
+  close(): void;
+  resolveConnectionsToMcp<T>(client: HubClient, connections: readonly AgentProfileConnection[], serverForGrant: (token: string) => T): Promise<ResolvedHubConnections<T>>;
+  register(input: {
+    client: HubClient;
+    connectionId: string;
+    capabilities: readonly string[];
+    /**
+     * Pre-resolved tool descriptors. When set, `listTools` returns
+     * these verbatim instead of calling `tools.describe` per capability path.
+     * The resolver pre-populates this for wildcard (`*`) grants, where it has
+     * already enumerated the connection's tools from a single `tools.search`,
+     * so the bridge does zero describe round-trips. `tools[].path` is still the
+     * authoritative allowlist `callTool` dispatches against.
+     */
+    tools?: readonly HubMcpToolDescriptor[];
+  }): string;
+  /**
+   * Revoke a single grant token. Returns true when a grant was removed. Safe
+   * to call on an already-revoked or never-issued token (returns false) so
+   * shutdown paths can revoke unconditionally without double-free risk.
+   */
+  revoke(token: string): boolean;
+  /** Trusted sidecar metadata for the native exact-effect permission hook. */
+  connectionId(token: string): string;
+  listTools(token: string): Promise<HubMcpToolDescriptor[]>;
+  callTool(token: string, name: string, args: unknown): Promise<HubMcpToolResult>;
+  private readGrant;
+}
+//#endregion
+//#region src/mcp/resolver.d.ts
+/**
+ * Resolution result. `mcp` is the runtime MCP server map the backend
+ * installs; `grantTokens` are the opaque sidecar-local grant handles that
+ * MUST be revoked when the owning backend shuts down (see
+ * `SdkBackend.shutdown`).
+ */
+type ResolvedHubConnections<T> = {
+  mcp: Record<string, T>;
+  grantTokens: string[]; /** Stable identity of the concrete connections and tools behind this result. */
+  resolutionKey: string;
+  /**
+   * Set when the result is an EMPTY toolbelt standing in for a failure the
+   * request tolerated (see the attach-all rule on `isAttachAllRequest`). The
+   * session runs, but with none of the tenant's integrations attached, so this
+   * must be surfaced — a silently empty toolbelt is exactly the trade the
+   * resolver's fail-loud posture exists to avoid.
+   */
+  degraded?: {
+    reason: "hub-unauthenticated";
+    message: string;
+    requestShape: "attach-all";
+  };
+};
+//#endregion
+//#region src/mcp/routes.d.ts
+declare function createHubMcpRoutes(scope: HubMcpScope): Hono;
+//#endregion
+export { HttpHubMcpBridgeClient, type HubMcpAuthRetry, HubMcpScope, type HubMcpScopeOptions, type HubMcpToolDescriptor, type HubMcpToolResult, type ResolvedHubConnections, createHubMcpBridgeServer, createHubMcpRoutes, lowerProfileConnections };
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/mcp/tools.ts","../../src/mcp/bridge.ts","../../src/mcp/profile.ts","../../src/mcp/scope.ts","../../src/mcp/resolver.ts","../../src/mcp/routes.ts"],"mappings":";;;;;;KAIY,oBAAA;EACV,IAAA;EACA,IAAA;EACA,WAAA;EACA,WAAA,EAAa,MAAA;AAAA;AAAA,KAGH,gBAAA;EACV,OAAA,EAAS,KAAA;IAAQ,IAAA;IAAc,IAAA;EAAA;EAC/B,OAAA;EALa;;;AAGf;;;EASE,iBAAA,GAAoB,MAAA;AAAA;;;UCTZ,kBAAA;EACR,SAAA,IAAa,OAAA,CAAQ,oBAAA;EACrB,QAAA,CAAS,IAAA,UAAc,IAAA,YAAgB,OAAA,CAAQ,gBAAA;AAAA;AAAA,cAGpC,sBAAA,YAAkC,kBAAA;EAAA,iBAC5B,QAAA;cAEL,QAAA;EAON,SAAA,CAAA,GAAa,OAAA,CAAQ,oBAAA;EAQrB,QAAA,CAAS,IAAA,UAAc,IAAA,YAAgB,OAAA,CAAQ,gBAAA;AAAA;AAAA,iBAQvC,wBAAA,CAAyB,MAAA,EAAQ,kBAAA,GAAqB,MAAA;;;;iBCpCtD,uBAAA,CACd,OAAA,EAAS,YAAA,cACT,UAAA,EAAY,MAAA,SAAe,qBAAA;EACxB,OAAA,GAAU,YAAA;EAAc,gBAAA,GAAmB,YAAA;AAAA;;;KCMpC,eAAA,OAAsB,SAAA,QAAiB,OAAA,CAAQ,CAAA,MAAO,OAAA,CAAQ,CAAA;AAAA,UACzD,kBAAA;EACf,IAAA,CAAK,KAAA;EACL,aAAA,GAAgB,eAAA;AAAA;;cAUL,WAAA;EAAA,iBAIkB,OAAA;EAAA,iBAHZ,MAAA;EAAA,QACT,MAAA;EAAA,iBACS,aAAA;cACY,OAAA,EAAS,kBAAA;EAGtC,KAAA,CAAA;EAIA,uBAAA,GAAA,CACE,MAAA,EAAQ,SAAA,EACR,WAAA,WAAsB,sBAAA,IACtB,cAAA,GAAiB,KAAA,aAAkB,CAAA,GAClC,OAAA,CAAQ,sBAAA,CAAuB,CAAA;EAQlC,QAAA,CAAS,KAAA;IACP,MAAA,EAAQ,SAAA;IACR,YAAA;IACA,YAAA;IH1CO;;;;;;;;IGmDP,KAAA,YAAiB,oBAAA;EAAA;;AFxDoD;;;;EE8EvE,MAAA,CAAO,KAAA;EFxEwC;EE6E/C,YAAA,CAAa,KAAA;EAIP,SAAA,CAAU,KAAA,WAAgB,OAAA,CAAQ,oBAAA;EAqClC,QAAA,CACJ,KAAA,UACA,IAAA,UAEA,IAAA,YACC,OAAA,CAAQ,gBAAA;EAAA,QAiFH,SAAA;AAAA;;;;;;AH9MV;;;KI+DY,sBAAA;EACV,GAAA,EAAK,MAAA,SAAe,CAAA;EACpB,WAAA,YJhEiB;EIkEjB,aAAA;EJjEA;;;;;;;EIyEA,QAAA;IACE,MAAA;IACA,OAAA;IACA,YAAA;EAAA;AAAA;;;iBCrFY,kBAAA,CAAmB,KAAA,EAAO,WAAA,GAAc,IAAA"}

package/dist/mcp/index.js

@@ -0,0 +1,482 @@
+import { b as isHubUnauthenticated, v as HubSdkError } from "../client-CsdLLECZ.js";
+import { n as createHubMcpBridgeServer, t as HttpHubMcpBridgeClient } from "../bridge-D8_lAKaW.js";
+import { Hono } from "hono";
+import { z } from "zod";
+import { randomBytes } from "node:crypto";
+//#region src/mcp/profile.ts
+/** Keep authored identity separate from runtime-only grant materialization. */
+function lowerProfileConnections(profile, runtimeMcp) {
+	if (!profile) return {};
+	const { connections: _connections, ...withoutConnections } = profile;
+	const collisions = Object.keys(runtimeMcp).filter((name) => name in (profile.mcp ?? {}));
+	if (collisions.length) throw new Error(`MCP server ${collisions.join(", ")} is declared by both the profile and the effective runtime; rename the profile server so it cannot be shadowed`);
+	return {
+		profile: withoutConnections,
+		workspaceProfile: {
+			...withoutConnections,
+			...Object.keys(runtimeMcp).length ? { mcp: {
+				...profile.mcp,
+				...runtimeMcp
+			} } : {}
+		}
+	};
+}
+//#endregion
+//#region src/mcp/routes.ts
+function createHubMcpRoutes(scope) {
+	const routes = new Hono();
+	const callToolSchema = z.object({
+		name: z.string().min(1),
+		arguments: z.unknown().optional()
+	});
+	routes.get("/grants/:token/tools", async (c) => {
+		const token = c.req.param("token");
+		try {
+			const tools = await scope.listTools(token);
+			return c.json({
+				tools,
+				connectionId: scope.connectionId(token)
+			});
+		} catch (error) {
+			return hubMcpError(c, error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	routes.post("/grants/:token/call", async (c) => {
+		const token = c.req.param("token");
+		const parsed = callToolSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			content: [{
+				type: "text",
+				text: "Invalid Hub MCP tool call request"
+			}],
+			isError: true
+		}, 400);
+		try {
+			const result = await scope.callTool(token, parsed.data.name, parsed.data.arguments ?? {});
+			return c.json(result);
+		} catch (error) {
+			return hubMcpError(c, error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	return routes;
+}
+function hubMcpError(c, error) {
+	const message = error.message;
+	return c.json({
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	}, 403);
+}
+//#endregion
+//#region src/mcp/tools.ts
+function assertConnectionIsActive(connection, connectionId) {
+	if (!connection) throw new HubSdkError({
+		code: "HUB_CONNECTION_MISSING",
+		message: `Hub connection "${connectionId}" not found for this principal`,
+		details: { connectionId }
+	});
+	if (connection.status !== "active") throw new HubSdkError({
+		code: connection.status === "revoked" ? "HUB_CONNECTION_REVOKED" : "HUB_CONNECTION_MISSING",
+		message: `Hub connection "${connectionId}" is "${connection.status}", expected "active"`,
+		details: {
+			connectionId,
+			providerId: connection.providerId,
+			status: connection.status
+		}
+	});
+}
+function toHubMcpToolName(path) {
+	return path.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function readInputSchema(tool) {
+	if (tool.inputSchema && typeof tool.inputSchema === "object" && !Array.isArray(tool.inputSchema)) return tool.inputSchema;
+	return {
+		type: "object",
+		properties: {}
+	};
+}
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+//#endregion
+//#region src/mcp/resolver.ts
+/**
+* Wildcard token. As a `connectionId` it means "every active connection of the
+* principal"; as the sole `capabilities` entry it means "every tool the
+* connection exposes". Both are expanded at session-spawn from cached
+* per-provider catalog searches (see `expandConnectionRefs`). The web dashboard emits
+* `{ connectionId: "*", capabilities: ["*"] }` to attach all connected hub
+* integrations; explicit CLI grants name concrete connections + paths.
+*/
+const WILDCARD = "*";
+/**
+* Whether every ref is the full attach-all sentinel — `{ connectionId: "*",
+* capabilities: ["*"] }`, naming neither a connection nor a capability.
+*
+* Such a request asserts nothing: "give me whatever integrations I happen to
+* have" is satisfied by an empty toolbelt, so resolving it to no servers is a
+* legitimate answer rather than a swallowed failure. Every other shape names
+* something that must exist — a concrete connection, or a concrete capability
+* fanned across connections — and stays fail-loud, mixed sets included.
+*/
+function isAttachAllRequest(refs) {
+	return refs.length > 0 && refs.every((ref) => ref.connectionId === WILDCARD && ref.capabilities.length === 1 && ref.capabilities[0] === WILDCARD);
+}
+/** Resolve required grants once, with rollback before the host's auth retry. */
+async function resolveConnectionsToMcp(client, connections, host) {
+	const empty = () => ({
+		mcp: {},
+		grantTokens: [],
+		resolutionKey: host.hash([])
+	});
+	if (connections.length === 0) return empty();
+	try {
+		return await host.withAuthRetry(() => resolveConnectionsOnce(client, connections, host));
+	} catch (error) {
+		if (!isHubUnauthenticated(error) || !isAttachAllRequest(connections)) throw error;
+		return {
+			...empty(),
+			degraded: {
+				reason: "hub-unauthenticated",
+				message: "Hub rejected the current credential and it could not be refreshed; no Hub integrations were attached",
+				requestShape: "attach-all"
+			}
+		};
+	}
+}
+async function resolveConnectionsOnce(client, connections, host) {
+	const listed = await client.connections.list();
+	const connectionsById = /* @__PURE__ */ new Map();
+	for (const conn of listed.connections) connectionsById.set(conn.id, conn);
+	const concreteRefs = await expandConnectionRefs(client, connections, listed.connections);
+	const resolutionKey = host.hash(concreteRefs.map((ref) => ({
+		connectionId: ref.connectionId,
+		providerId: connectionsById.get(ref.connectionId)?.providerId,
+		alias: ref.alias ?? defaultAliasFor(connectionsById.get(ref.connectionId)?.providerId ?? "", ref.connectionId, ref.capabilities),
+		capabilities: [...ref.capabilities].sort(),
+		descriptors: ref.descriptors ? [...ref.descriptors].sort((a, b) => a.path.localeCompare(b.path)) : void 0
+	})).sort((a, b) => `${a.connectionId}:${a.alias ?? ""}`.localeCompare(`${b.connectionId}:${b.alias ?? ""}`)));
+	const seenAliases = /* @__PURE__ */ new Map();
+	const mcp = {};
+	const grantTokens = [];
+	try {
+		for (const ref of concreteRefs) {
+			const conn = connectionsById.get(ref.connectionId);
+			assertConnectionIsActive(conn, ref.connectionId);
+			if (!ref.descriptors) for (const capabilityPath of ref.capabilities) {
+				const tool = (await client.tools.describe(capabilityPath)).tool;
+				if (tool.requiredConnectionProviderId !== void 0 && tool.requiredConnectionProviderId !== conn.providerId) throw new HubSdkError({
+					code: "HUB_INVALID_INPUT",
+					message: `Capability "${capabilityPath}" requires provider "${tool.requiredConnectionProviderId}" but connection "${ref.connectionId}" is "${conn.providerId}"`,
+					details: {
+						connectionId: ref.connectionId,
+						providerId: conn.providerId,
+						capabilityPath,
+						requiredProviderId: tool.requiredConnectionProviderId
+					}
+				});
+			}
+			const alias = ref.alias ?? defaultAliasFor(conn.providerId, ref.connectionId, ref.capabilities);
+			const previousConnectionId = seenAliases.get(alias);
+			if (previousConnectionId !== void 0) throw new HubSdkError({
+				code: "HUB_INVALID_INPUT",
+				message: `Duplicate MCP alias "${alias}" — each hub connection grant must have a unique alias (connections "${previousConnectionId}" and "${ref.connectionId}")`,
+				details: {
+					alias,
+					connectionId: ref.connectionId,
+					previousConnectionId
+				}
+			});
+			seenAliases.set(alias, ref.connectionId);
+			const grantToken = host.grants.register({
+				client,
+				connectionId: ref.connectionId,
+				capabilities: ref.capabilities,
+				tools: ref.descriptors
+			});
+			grantTokens.push(grantToken);
+			mcp[alias] = host.serverForGrant(grantToken);
+		}
+	} catch (error) {
+		for (const token of grantTokens) host.grants.revoke(token);
+		throw error;
+	}
+	return {
+		mcp,
+		grantTokens,
+		resolutionKey
+	};
+}
+/**
+* Expand `*` wildcards into concrete connection refs.
+*
+*   - `connectionId: "*"` fans out to one ref per ACTIVE connection, carrying
+*     the original capability set. This is the web dashboard's "attach all my
+*     connected integrations" sentinel — best-effort, so a connection that
+*     resolves to zero tools is dropped rather than producing an empty server.
+*   - `capabilities: ["*"]` enumerates the connection's tools from a cached
+*     provider-scoped `tools.search("", { provider })` and emits the concrete
+*     paths plus pre-built descriptors. An EXPLICIT
+*     connection that exposes no tools fails loud (the caller named it); a
+*     wildcard-connection one is skipped.
+*
+* Explicit (non-wildcard) refs pass through untouched for the existing
+* fail-loud validation path.
+*/
+async function expandConnectionRefs(client, refs, allConnections) {
+	const active = allConnections.filter((c) => c.status === "active");
+	const catalogByProvider = /* @__PURE__ */ new Map();
+	const loadCatalog = (providerId) => {
+		let cached = catalogByProvider.get(providerId);
+		if (cached === void 0) {
+			cached = client.tools.search("", {
+				provider: providerId,
+				limit: 200
+			}).then((res) => res.tools ?? []);
+			catalogByProvider.set(providerId, cached);
+		}
+		return cached;
+	};
+	const connExpanded = refs.flatMap((ref) => {
+		if (ref.connectionId === WILDCARD) return active.map((conn) => ({
+			connectionId: conn.id,
+			capabilities: [...ref.capabilities],
+			fromWildcardConnection: true
+		}));
+		return [{
+			connectionId: ref.connectionId,
+			capabilities: [...ref.capabilities],
+			alias: ref.alias,
+			fromWildcardConnection: false
+		}];
+	});
+	for (const ref of connExpanded) if (ref.capabilities.length === 1 && ref.capabilities[0] === WILDCARD) {
+		const conn = connectionsByIdLookup(allConnections, ref.connectionId);
+		if (conn?.status === "active") loadCatalog(conn.providerId).catch(() => {});
+	}
+	const out = [];
+	for (const ref of connExpanded) {
+		if (!(ref.capabilities.length === 1 && ref.capabilities[0] === WILDCARD)) {
+			out.push({
+				connectionId: ref.connectionId,
+				capabilities: ref.capabilities,
+				alias: ref.alias,
+				fromWildcardConnection: ref.fromWildcardConnection
+			});
+			continue;
+		}
+		const conn = connectionsByIdLookup(allConnections, ref.connectionId);
+		if (!conn || conn.status !== "active") {
+			out.push({
+				connectionId: ref.connectionId,
+				capabilities: [WILDCARD],
+				alias: ref.alias,
+				fromWildcardConnection: ref.fromWildcardConnection
+			});
+			continue;
+		}
+		const descriptors = buildToolDescriptors((await loadCatalog(conn.providerId)).filter((t) => t.connectionStatus === "connected" && (t.requiredConnectionProviderId ?? t.providerId) === conn.providerId));
+		if (descriptors.length === 0) {
+			if (ref.fromWildcardConnection) continue;
+			throw new HubSdkError({
+				code: "HUB_INVALID_INPUT",
+				message: `Connection "${ref.connectionId}" (${conn.providerId}) exposes no tools — cannot expand capability \`*\``,
+				details: {
+					connectionId: ref.connectionId,
+					providerId: conn.providerId
+				}
+			});
+		}
+		out.push({
+			connectionId: ref.connectionId,
+			capabilities: descriptors.map((d) => d.path),
+			alias: ref.alias,
+			descriptors,
+			fromWildcardConnection: ref.fromWildcardConnection
+		});
+	}
+	return out;
+}
+function connectionsByIdLookup(connections, id) {
+	return connections.find((c) => c.id === id);
+}
+/**
+* Build MCP tool descriptors from catalog search results, deduping by the
+* sanitized MCP tool name (hub paths with the same leaf collapse, matching the
+* grant bridge's own naming).
+*/
+function buildToolDescriptors(tools) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const tool of tools) {
+		const name = toHubMcpToolName(tool.path);
+		if (seen.has(name)) continue;
+		seen.add(name);
+		out.push({
+			name,
+			path: tool.path,
+			description: tool.description ?? tool.title ?? tool.path,
+			inputSchema: tool.inputSchema && typeof tool.inputSchema === "object" && !Array.isArray(tool.inputSchema) ? tool.inputSchema : {
+				type: "object",
+				properties: {}
+			}
+		});
+	}
+	return out;
+}
+function defaultAliasFor(providerId, connectionId, capabilityPaths) {
+	return `${providerId}-${connectionId.replace(/^(hubconn_|conn_)/, "").replace(new RegExp(`^${escapeRegExp(providerId)}_`), "").replace(/[^a-zA-Z0-9]/g, "").slice(-8)}-${capabilityPaths.length === 1 ? capabilityPaths[0]?.split(".").pop() ?? capabilityPaths[0] : "tools"}`.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/mcp/scope.ts
+/** Opaque grants owned by one embedded host; close revokes only this scope. */
+var HubMcpScope = class {
+	grants = /* @__PURE__ */ new Map();
+	closed = false;
+	withAuthRetry;
+	constructor(options) {
+		this.options = options;
+		this.withAuthRetry = options.withAuthRetry ?? ((operation) => operation());
+	}
+	close() {
+		this.closed = true;
+		this.grants.clear();
+	}
+	resolveConnectionsToMcp(client, connections, serverForGrant) {
+		return resolveConnectionsToMcp(client, connections, {
+			grants: this,
+			hash: this.options.hash,
+			withAuthRetry: this.withAuthRetry,
+			serverForGrant
+		});
+	}
+	register(input) {
+		if (this.closed) throw new HubSdkError({
+			code: "HUB_POLICY_DENIED",
+			message: "Hub MCP scope is closed"
+		});
+		const token = `hmcp_${randomBytes(32).toString("base64url")}`;
+		this.grants.set(token, {
+			client: input.client,
+			connectionId: input.connectionId,
+			capabilities: [...input.capabilities],
+			tools: input.tools ? [...input.tools] : void 0
+		});
+		return token;
+	}
+	/**
+	* Revoke a single grant token. Returns true when a grant was removed. Safe
+	* to call on an already-revoked or never-issued token (returns false) so
+	* shutdown paths can revoke unconditionally without double-free risk.
+	*/
+	revoke(token) {
+		return this.grants.delete(token);
+	}
+	/** Trusted sidecar metadata for the native exact-effect permission hook. */
+	connectionId(token) {
+		return this.readGrant(token).connectionId;
+	}
+	async listTools(token) {
+		const grant = this.readGrant(token);
+		if (grant.tools) return grant.tools;
+		const resolved = [];
+		const seenNames = /* @__PURE__ */ new Set();
+		for (const path of grant.capabilities) {
+			const tool = (await this.withAuthRetry(() => {
+				this.readGrant(token);
+				return grant.client.tools.describe(path);
+			})).tool;
+			const name = toHubMcpToolName(path);
+			if (seenNames.has(name)) throw new HubSdkError({
+				code: "HUB_INVALID_INPUT",
+				message: `Duplicate MCP tool name "${name}" for Hub grant`,
+				details: {
+					connectionId: grant.connectionId,
+					path
+				}
+			});
+			seenNames.add(name);
+			resolved.push({
+				name,
+				path,
+				description: tool.description ?? tool.title ?? path,
+				inputSchema: readInputSchema(tool)
+			});
+		}
+		this.readGrant(token);
+		grant.tools = resolved;
+		return resolved;
+	}
+	async callTool(token, name, args) {
+		const grant = this.readGrant(token);
+		const tool = (await this.listTools(token)).find((candidate) => candidate.name === name);
+		if (!tool) return errorResult(`Unknown tool: ${name}`);
+		let effectInvocation;
+		let effectArgs = args ?? {};
+		if (effectArgs && typeof effectArgs === "object" && !Array.isArray(effectArgs) && Object.hasOwn(effectArgs, "__tangle_effect_invocation")) {
+			const { __tangle_effect_invocation: invocation, ...original } = effectArgs;
+			if (typeof invocation !== "string" || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(invocation)) return errorResult("Invalid native effect invocation");
+			effectInvocation = invocation;
+			effectArgs = original;
+		}
+		this.readGrant(token);
+		try {
+			const result = await this.withAuthRetry(() => {
+				this.readGrant(token);
+				return grant.client.tools.invoke(tool.path, effectArgs, {
+					connectionId: grant.connectionId,
+					...effectInvocation ? { idempotencyKey: `line-effect:${effectInvocation}` } : {}
+				});
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result.result ?? result)
+			}] };
+		} catch (error) {
+			if (error instanceof HubSdkError) {
+				const approval = error.code === "HUB_APPROVAL_REQUIRED" ? error.details?.approval : void 0;
+				return {
+					content: [{
+						type: "text",
+						text: approval ? JSON.stringify({
+							code: error.code,
+							message: error.message,
+							approval
+						}) : `${error.code}: ${error.message}`
+					}],
+					isError: true,
+					structuredContent: {
+						code: error.code,
+						message: error.message,
+						...error.details ? { details: error.details } : {}
+					}
+				};
+			}
+			return errorResult(error instanceof Error ? error.message : String(error));
+		}
+	}
+	readGrant(token) {
+		const grant = this.grants.get(token);
+		if (!grant) throw new HubSdkError({
+			code: "HUB_POLICY_DENIED",
+			message: "Unknown Hub MCP grant token"
+		});
+		return grant;
+	}
+};
+//#endregion
+export { HttpHubMcpBridgeClient, HubMcpScope, createHubMcpBridgeServer, createHubMcpRoutes, lowerProfileConnections };
+
+//# sourceMappingURL=index.js.map