@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.18

package/dist/ApprovalInboxPage-dbBDSJ-f.js

@@ -0,0 +1,558 @@
+"use client";
+import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
+import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
+import { r as usePendingHumanRequests, t as HumanRequestCard } from "./HumanRequestCard-D-ooVPDn.js";
+import { t as FluidGridsDocsLink } from "./FluidGridsDocsLink-JxkBpOeb.js";
+import { _ as throwIfResultError, h as isForbiddenError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { i as SdkPermissionButton, s as useFluidGridsPermission, t as FLUIDGRIDS_PERMISSIONS } from "./constants-B2lhWNoN.js";
+import { useCallback, useEffect, useState } from "react";
+import { useNavigate } from "react-router";
+import { Icon } from "@iconify/react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { toast } from "sonner";
+import { gql } from "@apollo/client";
+import { Badge, Card, CardContent, CardHeader, Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle, Label, Textarea } from "@burdenoff/fe-libs/ui";
+import { Button as Button$1 } from "@burdenoff/fe-libs/button";
+
+// src/modules/tool-approval/hooks/useToolApprovals.ts
+/**
+* Custom hooks for the AI Agent tool-approval inbox (BOFF-7521).
+* Queries/mutates wspace-workflow-svc via the federated GraphQL gateway —
+* mirrors the variables module's hook pattern
+* (`modules/variables/hooks/useVariables.ts`).
+*/
+const TOOL_APPROVAL_FIELDS = gql`
+  fragment ToolApprovalRequestFields on ToolApprovalRequest {
+    id
+    runId
+    nodeId
+    workflowId
+    workflowKey
+    status
+    toolCalls {
+      callId
+      name
+      argsJson
+    }
+    decisions {
+      callId
+      decision
+      reason
+    }
+    timeoutAt
+    timeoutAction
+    requestedAt
+    decidedAt
+    decidedBy
+  }
+`;
+const GET_PENDING_TOOL_APPROVALS = gql`
+  ${TOOL_APPROVAL_FIELDS}
+  query GetPendingToolApprovals($limit: Int, $offset: Int) {
+    pendingToolApprovals(limit: $limit, offset: $offset) {
+      totalCount
+      items {
+        ...ToolApprovalRequestFields
+      }
+    }
+  }
+`;
+const DECIDE_TOOL_APPROVAL = gql`
+  ${TOOL_APPROVAL_FIELDS}
+  mutation DecideToolApproval(
+    $id: ID!
+    $decisions: [ToolApprovalDecisionInput!]!
+  ) {
+    decideToolApproval(id: $id, decisions: $decisions) {
+      success
+      error
+      resumedFromNodeId
+      request {
+        ...ToolApprovalRequestFields
+      }
+    }
+  }
+`;
+/**
+* Polls the pending tool-approval inbox. Short polling interval (not a
+* subscription) — approvals are rare/low-volume and the caller wants a
+* near-real-time inbox without standing up a dedicated subscription channel
+* for a v1 feature.
+*
+* Pass `enabled: false` when the caller lacks `tool-approval-request:read`:
+* the query is then never sent, so the gateway's FORBIDDEN never reaches the
+* shell's global error toast (BOFF-10104). If the gateway still denies the
+* query, `forbidden` turns true and polling stops.
+*/
+function usePendingToolApprovals(options) {
+	const limit = options?.limit ?? 50;
+	const offset = options?.offset ?? 0;
+	const pollIntervalMs = options?.pollIntervalMs ?? 15e3;
+	const enabled = options?.enabled ?? true;
+	const [items, setItems] = useState([]);
+	const [totalCount, setTotalCount] = useState(0);
+	const [loading, setLoading] = useState(enabled);
+	const [error, setError] = useState(null);
+	const [forbidden, setForbidden] = useState(false);
+	const fetchData = useCallback(async () => {
+		if (!enabled) return;
+		setError(null);
+		try {
+			const client = getFluidGridsClient();
+			const result = throwIfResultError(await client.query({
+				query: GET_PENDING_TOOL_APPROVALS,
+				variables: {
+					limit,
+					offset
+				},
+				fetchPolicy: "network-only"
+			}));
+			setItems(result.data?.pendingToolApprovals?.items ?? []);
+			setTotalCount(result.data?.pendingToolApprovals?.totalCount ?? 0);
+		} catch (err) {
+			if (isForbiddenError(err)) {
+				setForbidden(true);
+				setItems([]);
+				setTotalCount(0);
+			} else setError(err);
+		} finally {
+			setLoading(false);
+		}
+	}, [
+		enabled,
+		limit,
+		offset
+	]);
+	useEffect(() => {
+		setForbidden(false);
+		if (!enabled) {
+			setItems([]);
+			setTotalCount(0);
+			setError(null);
+		}
+	}, [enabled]);
+	useEffect(() => {
+		if (!enabled || forbidden) {
+			setLoading(false);
+			return;
+		}
+		setLoading(true);
+		fetchData();
+		if (pollIntervalMs <= 0) return;
+		const interval = setInterval(fetchData, pollIntervalMs);
+		return () => clearInterval(interval);
+	}, [
+		enabled,
+		fetchData,
+		forbidden,
+		pollIntervalMs
+	]);
+	return {
+		items,
+		totalCount,
+		loading,
+		error,
+		forbidden: forbidden || !enabled,
+		refetch: fetchData
+	};
+}
+function useDecideToolApproval() {
+	const [loading, setLoading] = useState(false);
+	const [error, setError] = useState(null);
+	const decide = useCallback(async (id, decisions) => {
+		setLoading(true);
+		setError(null);
+		try {
+			const client = getFluidGridsClient();
+			const response = throwIfResultError(await client.mutate({
+				mutation: DECIDE_TOOL_APPROVAL,
+				variables: {
+					id,
+					decisions
+				}
+			})).data?.decideToolApproval;
+			if (!response?.success) throw new Error(response?.error ?? "Failed to record the decision");
+			return response;
+		} catch (err) {
+			setError(err);
+			throw err;
+		} finally {
+			setLoading(false);
+		}
+	}, []);
+	return {
+		decide,
+		decideAll: useCallback(async (request, decision, reason) => {
+			return decide(request.id, request.toolCalls.map((call) => ({
+				callId: call.callId,
+				decision,
+				reason
+			})));
+		}, [decide]),
+		loading,
+		error
+	};
+}
+
+// src/modules/tool-approval/utils/timeout.ts
+/**
+* Classifies timeout metadata without changing server-owned request status.
+* The timeout sweep remains authoritative for auto-resolving WAITING runs.
+*/
+function getToolApprovalTimeoutState(timeoutAt, nowMs = Date.now()) {
+	if (!timeoutAt) return "NONE";
+	const timeoutMs = Date.parse(timeoutAt);
+	if (!Number.isFinite(timeoutMs)) return "NONE";
+	return timeoutMs <= nowMs ? "DUE" : "ACTIVE";
+}
+
+// src/modules/tool-approval/pages/ApprovalInboxPage.tsx
+/**
+* Tool Approval Inbox (BOFF-7521)
+*
+* Human-in-the-loop gate for AI Agent tool calls: lists every run currently
+* paused waiting for a decision, shows the proposed tool call(s) and their
+* arguments, and lets the reviewer approve or reject the whole batch (or, in
+* a future iteration, individual calls). Approving/rejecting resumes the
+* underlying run via `decideToolApproval`, which reuses the exact same
+* WAITING/`resumeWorkflowRun` mechanism the Wait node uses.
+*/
+var ApprovalInboxPage_exports = /* @__PURE__ */ __exportAll({ ApprovalInboxPage: () => ApprovalInboxPage });
+function formatArgs(argsJson) {
+	try {
+		return JSON.stringify(JSON.parse(argsJson), null, 2);
+	} catch {
+		return argsJson;
+	}
+}
+function timeAgo(iso, tr) {
+	const then = new Date(iso).getTime();
+	const diffMs = Date.now() - then;
+	const minutes = Math.floor(diffMs / 6e4);
+	if (minutes < 1) return tr("fluidgrids.toolApproval.justNow", "just now");
+	if (minutes < 60) return tr("fluidgrids.toolApproval.minutesAgo", "{{minutes}}m ago", { minutes });
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return tr("fluidgrids.toolApproval.hoursAgo", "{{hours}}h ago", { hours });
+	return tr("fluidgrids.toolApproval.daysAgo", "{{days}}d ago", { days: Math.floor(hours / 24) });
+}
+function RejectDialog({ open, onOpenChange, onConfirm, submitting }) {
+	const tr = useTr();
+	const [reason, setReason] = useState("");
+	return /* @__PURE__ */ jsx(Dialog, {
+		open,
+		onOpenChange,
+		children: /* @__PURE__ */ jsxs(DialogContent, { children: [
+			/* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: tr("fluidgrids.toolApproval.rejectDialogTitle", "Reject tool call") }) }),
+			/* @__PURE__ */ jsxs("div", {
+				className: "space-y-1.5",
+				children: [/* @__PURE__ */ jsx(Label, {
+					htmlFor: "reject-reason",
+					children: tr("fluidgrids.toolApproval.rejectReasonLabel", "Reason (optional)")
+				}), /* @__PURE__ */ jsx(Textarea, {
+					id: "reject-reason",
+					value: reason,
+					onChange: (e) => setReason(e.target.value),
+					placeholder: tr("fluidgrids.toolApproval.rejectReasonPlaceholder", "Why is this call being rejected? The agent sees this.")
+				})]
+			}),
+			/* @__PURE__ */ jsxs(DialogFooter, { children: [/* @__PURE__ */ jsx(Button$1, {
+				variant: "outline",
+				onClick: () => onOpenChange(false),
+				disabled: submitting,
+				children: tr("fluidgrids.toolApproval.cancel", "Cancel")
+			}), /* @__PURE__ */ jsx(Button$1, {
+				variant: "destructive",
+				onClick: () => onConfirm(reason),
+				disabled: submitting,
+				children: submitting ? tr("fluidgrids.toolApproval.rejecting", "Rejecting…") : tr("fluidgrids.toolApproval.rejectConfirm", "Reject")
+			})] })
+		] })
+	});
+}
+function RequestCard({ request, onDecided }) {
+	const tr = useTr();
+	const { decideAll, loading } = useDecideToolApproval();
+	const [showReject, setShowReject] = useState(false);
+	const [nowMs, setNowMs] = useState(() => Date.now());
+	const timeoutState = getToolApprovalTimeoutState(request.timeoutAt, nowMs);
+	const timeoutDue = timeoutState === "DUE";
+	useEffect(() => {
+		if (timeoutState !== "ACTIVE") return;
+		const interval = setInterval(() => setNowMs(Date.now()), 1e3);
+		return () => clearInterval(interval);
+	}, [timeoutState]);
+	const handleDecide = async (decision, reason) => {
+		try {
+			await decideAll(request, decision, reason);
+			toast.success(decision === "APPROVED" ? tr("fluidgrids.toolApproval.approvedToast", "Tool call approved — run resumed") : tr("fluidgrids.toolApproval.rejectedToast", "Tool call rejected — run resumed"));
+			setShowReject(false);
+			onDecided();
+		} catch (err) {
+			toast.error(err instanceof Error ? err.message : tr("fluidgrids.toolApproval.decisionFailed", "Failed to record the decision"));
+		}
+	};
+	return /* @__PURE__ */ jsxs(Card, {
+		className: "border border-border-secondary bg-background-secondary",
+		"data-testid": "tool-approval-card",
+		"data-request-id": request.id,
+		children: [
+			/* @__PURE__ */ jsxs(CardHeader, {
+				className: "pb-3",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "flex flex-wrap items-center justify-between gap-2",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "flex items-center gap-2",
+						children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "mdi:robot-outline",
+							width: 18,
+							className: "text-text-secondary"
+						}), /* @__PURE__ */ jsxs("span", {
+							className: "text-sm font-semibold text-text-primary",
+							children: [
+								tr("fluidgrids.toolApproval.nodeLabel", "Node"),
+								":",
+								" ",
+								request.nodeId
+							]
+						})]
+					}), /* @__PURE__ */ jsx(Badge, {
+						variant: "outline",
+						className: "font-mono text-[10px]",
+						children: request.workflowKey
+					})]
+				}), /* @__PURE__ */ jsxs("p", {
+					className: "text-xs text-text-secondary",
+					children: [tr("fluidgrids.toolApproval.requestedAt", "Requested {{when}}", { when: timeAgo(request.requestedAt, tr) }), request.timeoutAt && timeoutDue ? ` · ${tr("fluidgrids.toolApproval.timeoutDue", "timeout reached; automatic decision pending")}` : request.timeoutAt && ` · ${tr("fluidgrids.toolApproval.autoResolvesAt", "auto-resolves at {{time}}", { time: new Date(request.timeoutAt).toLocaleString() })}`]
+				})]
+			}),
+			/* @__PURE__ */ jsxs(CardContent, {
+				className: "space-y-3",
+				children: [request.toolCalls.map((call) => /* @__PURE__ */ jsxs("div", {
+					className: "rounded-md border border-border-secondary bg-background-primary p-3",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "mb-1 flex items-center gap-2",
+						children: [/* @__PURE__ */ jsx(Icon, {
+							icon: "mdi:function-variant",
+							width: 14,
+							className: "text-text-secondary"
+						}), /* @__PURE__ */ jsx("span", {
+							className: "text-sm font-medium text-text-primary",
+							children: call.name
+						})]
+					}), /* @__PURE__ */ jsx("pre", {
+						className: "overflow-x-auto whitespace-pre-wrap break-all text-xs text-text-secondary",
+						children: formatArgs(call.argsJson)
+					})]
+				}, call.callId)), /* @__PURE__ */ jsxs("div", {
+					className: "flex items-center gap-2 pt-1",
+					children: [/* @__PURE__ */ jsx(SdkPermissionButton, {
+						permission: FLUIDGRIDS_PERMISSIONS.TOOL_APPROVAL_REQUEST_EXECUTE,
+						deniedTooltip: tr("fluidgrids.toolApproval.decideDeniedTooltip", "You don't have permission to decide tool approvals"),
+						children: /* @__PURE__ */ jsxs(Button$1, {
+							"data-agent": "confirm",
+							size: "sm",
+							disabled: loading || timeoutDue,
+							onClick: () => handleDecide("APPROVED"),
+							"data-testid": "tool-approval-approve",
+							children: [/* @__PURE__ */ jsx(Icon, {
+								icon: "mdi:check",
+								className: "mr-1.5",
+								width: 16
+							}), tr("fluidgrids.toolApproval.approve", "Approve")]
+						})
+					}), /* @__PURE__ */ jsx(SdkPermissionButton, {
+						permission: FLUIDGRIDS_PERMISSIONS.TOOL_APPROVAL_REQUEST_EXECUTE,
+						deniedTooltip: tr("fluidgrids.toolApproval.decideDeniedTooltip", "You don't have permission to decide tool approvals"),
+						children: /* @__PURE__ */ jsxs(Button$1, {
+							size: "sm",
+							variant: "destructive",
+							disabled: loading || timeoutDue,
+							onClick: () => setShowReject(true),
+							"data-testid": "tool-approval-reject",
+							children: [/* @__PURE__ */ jsx(Icon, {
+								icon: "mdi:close",
+								className: "mr-1.5",
+								width: 16
+							}), tr("fluidgrids.toolApproval.reject", "Reject")]
+						})
+					})]
+				})]
+			}),
+			/* @__PURE__ */ jsx(RejectDialog, {
+				open: showReject,
+				onOpenChange: setShowReject,
+				submitting: loading,
+				onConfirm: (reason) => handleDecide("REJECTED", reason || void 0)
+			})
+		]
+	});
+}
+const HUMAN_PAGE_SIZE = 50;
+function ApprovalInboxPage() {
+	const tr = useTr();
+	const navigate = useNavigate();
+	const { allowed: canReadToolApprovals, isLoading: permissionsLoading } = useFluidGridsPermission(FLUIDGRIDS_PERMISSIONS.TOOL_APPROVAL_REQUEST_READ);
+	const { items, totalCount, loading, error, forbidden, refetch } = usePendingToolApprovals({ enabled: canReadToolApprovals });
+	const toolsForbidden = forbidden && !permissionsLoading;
+	const [humanOffset, setHumanOffset] = useState(0);
+	const human = usePendingHumanRequests({
+		limit: HUMAN_PAGE_SIZE,
+		offset: humanOffset
+	});
+	const humanTotal = human.totalCount;
+	useEffect(() => {
+		if (humanOffset > 0 && humanOffset >= humanTotal) setHumanOffset(Math.max(0, Math.ceil(humanTotal / HUMAN_PAGE_SIZE) - 1) * HUMAN_PAGE_SIZE);
+	}, [humanOffset, humanTotal]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "p-4 sm:p-6 bg-background-primary min-h-screen",
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4 mb-6",
+				"data-tour": "fluidgrids-approvals-header",
+				children: [/* @__PURE__ */ jsxs("div", { children: [
+					/* @__PURE__ */ jsx("h1", {
+						className: "text-2xl sm:text-3xl font-bold text-text-primary",
+						children: tr("fluidgrids.approvals.pageTitle", "Approvals")
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "text-text-secondary mt-1",
+						children: tr("fluidgrids.approvals.pageSubtitle", "Requests from your workflows waiting for a person, and AI Agent tool calls waiting for a decision")
+					}),
+					/* @__PURE__ */ jsx(FluidGridsDocsLink, {
+						topic: "approvals",
+						className: "mt-1"
+					})
+				] }), /* @__PURE__ */ jsxs(Button$1, {
+					variant: "outline",
+					onClick: () => navigate("../runs"),
+					children: [/* @__PURE__ */ jsx(Icon, {
+						icon: "mdi:arrow-left",
+						className: "mr-2",
+						width: 16
+					}), tr("fluidgrids.toolApproval.backToRuns", "Back to Runs")]
+				})]
+			}),
+			(loading || permissionsLoading) && items.length === 0 && /* @__PURE__ */ jsx("p", {
+				className: "text-text-secondary text-sm",
+				children: tr("fluidgrids.toolApproval.loading", "Loading…")
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				className: "text-sm text-destructive",
+				role: "alert",
+				children: tr("fluidgrids.toolApproval.loadFailed", "Failed to load pending approvals: {{message}}", { message: error.message })
+			}),
+			human.items.length > 0 && /* @__PURE__ */ jsxs("section", {
+				className: "mb-8",
+				"data-testid": "human-requests-section",
+				"data-tour": "fluidgrids-approvals-human",
+				children: [
+					/* @__PURE__ */ jsx("h2", {
+						className: "mb-1 text-lg font-semibold text-text-primary",
+						children: tr("fluidgrids.humanResponse.inboxHeading", "Waiting for a response")
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "mb-3 text-xs text-text-secondary",
+						children: tr("fluidgrids.humanResponse.inboxSubtitle", "Workflows paused on a person — approve, decline or answer to let them continue.")
+					}),
+					/* @__PURE__ */ jsx("div", {
+						className: "grid grid-cols-1 gap-4 lg:grid-cols-2",
+						children: human.items.map((request) => /* @__PURE__ */ jsx(HumanRequestCard, {
+							request,
+							onAnswered: human.refetch
+						}, request.id))
+					}),
+					human.totalCount > HUMAN_PAGE_SIZE && /* @__PURE__ */ jsxs("div", {
+						className: "mt-4 flex items-center gap-3",
+						children: [
+							/* @__PURE__ */ jsx("span", {
+								className: "text-xs text-text-secondary",
+								children: tr("fluidgrids.humanResponse.pageRange", "{{from}}–{{to}} of {{total}}", {
+									from: humanOffset + 1,
+									to: humanOffset + human.items.length,
+									total: human.totalCount
+								})
+							}),
+							/* @__PURE__ */ jsx(Button$1, {
+								variant: "outline",
+								size: "sm",
+								disabled: humanOffset === 0,
+								onClick: () => setHumanOffset((current) => Math.max(0, current - HUMAN_PAGE_SIZE)),
+								children: tr("fluidgrids.humanResponse.previousPage", "Previous")
+							}),
+							/* @__PURE__ */ jsx(Button$1, {
+								variant: "outline",
+								size: "sm",
+								disabled: humanOffset + HUMAN_PAGE_SIZE >= human.totalCount,
+								onClick: () => setHumanOffset((current) => current + HUMAN_PAGE_SIZE),
+								children: tr("fluidgrids.humanResponse.nextPage", "Next")
+							})
+						]
+					})
+				]
+			}),
+			human.error && /* @__PURE__ */ jsx("p", {
+				className: "mb-4 text-sm text-destructive",
+				role: "alert",
+				children: tr("fluidgrids.humanResponse.loadFailed", "Failed to load requests waiting for a response: {{message}}", { message: human.error.message })
+			}),
+			toolsForbidden && /* @__PURE__ */ jsx(Card, {
+				className: "mb-6 border border-border-secondary bg-background-secondary",
+				"data-testid": "tool-approval-no-access",
+				children: /* @__PURE__ */ jsxs(CardContent, {
+					className: "flex items-start gap-3 py-4",
+					children: [/* @__PURE__ */ jsx(Icon, {
+						icon: "mdi:lock-outline",
+						width: 20,
+						className: "mt-0.5 shrink-0 text-text-secondary"
+					}), /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("p", {
+						className: "text-sm font-medium text-text-primary",
+						children: tr("fluidgrids.toolApproval.noAccessTitle", "You can't review AI Agent tool calls")
+					}), /* @__PURE__ */ jsx("p", {
+						className: "mt-1 text-xs text-text-secondary",
+						children: tr("fluidgrids.toolApproval.noAccessSubtitle", "Your role doesn't include permission to read tool approval requests. Ask a workspace admin if you need access.")
+					})] })]
+				})
+			}),
+			!loading && !permissionsLoading && !toolsForbidden && !error && !human.loading && !human.error && items.length === 0 && human.items.length === 0 && /* @__PURE__ */ jsx(Card, {
+				className: "border border-border-secondary bg-background-secondary",
+				"data-tour": "fluidgrids-approvals-empty",
+				children: /* @__PURE__ */ jsxs(CardContent, {
+					className: "flex flex-col items-center gap-2 py-10 text-center",
+					children: [
+						/* @__PURE__ */ jsx(Icon, {
+							icon: "mdi:shield-check-outline",
+							width: 32,
+							className: "text-text-secondary"
+						}),
+						/* @__PURE__ */ jsx("p", {
+							className: "text-sm font-medium text-text-primary",
+							children: tr("fluidgrids.toolApproval.emptyTitle", "Nothing waiting for approval")
+						}),
+						/* @__PURE__ */ jsx("p", {
+							className: "text-xs text-text-secondary",
+							children: tr("fluidgrids.toolApproval.emptySubtitle", "Runs will appear here when an AI Agent with tool approval enabled proposes a tool call.")
+						})
+					]
+				})
+			}),
+			!toolsForbidden && items.length > 0 && /* @__PURE__ */ jsx("div", {
+				className: "mb-3 text-xs text-text-secondary",
+				"data-testid": "tool-approval-count",
+				children: tr("fluidgrids.toolApproval.count", "{{count}} pending ({{total}} total)", {
+					count: items.length,
+					total: totalCount
+				})
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "grid grid-cols-1 gap-4 lg:grid-cols-2",
+				"data-tour": "fluidgrids-approvals-tools",
+				children: !toolsForbidden && items.map((request) => /* @__PURE__ */ jsx(RequestCard, {
+					request,
+					onDecided: refetch
+				}, request.id))
+			})
+		]
+	});
+}
+
+export { usePendingToolApprovals as i, ApprovalInboxPage_exports as n, useDecideToolApproval as r, ApprovalInboxPage as t };