@datalayer/agent-runtimes 1.0.2 → 1.0.3

package/lib/hooks/useMonitoring.js

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Agent monitoring hooks.
+ *
+ * @module hooks/useMonitoring
+ */
+import { useEffect, useState } from 'react';
+import { createOtelClient } from '@datalayer/core/lib/otel';
+export function toMetricValue(row) {
+    const candidates = [row.value_double, row.value_int, row.value];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+            return candidate;
+        }
+        if (typeof candidate === 'string') {
+            const parsed = Number(candidate);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return 0;
+}
+export async function fetchOtelMetricRows({ metric, serviceName, runUrl, apiKey, limit = 500, }) {
+    const client = createOtelClient({
+        baseUrl: runUrl,
+        token: apiKey,
+    });
+    const filtered = await client.fetchMetrics({
+        metricName: metric,
+        serviceName,
+        limit,
+    });
+    if (filtered.data.length > 0 || !serviceName) {
+        return filtered.data;
+    }
+    const fallback = await client.fetchMetrics({
+        metricName: metric,
+        limit,
+    });
+    return fallback.data;
+}
+export async function fetchOtelMetricTotal(options) {
+    const rows = await fetchOtelMetricRows(options);
+    return rows.reduce((sum, row) => sum + toMetricValue(row), 0);
+}
+export async function fetchOtelTotalTokens({ serviceName, runUrl, apiKey, limit = 500, }) {
+    const total = await fetchOtelMetricTotal({
+        metric: 'agent_runtimes.prompt.turn.total_tokens',
+        serviceName,
+        runUrl,
+        apiKey,
+        limit,
+    });
+    if (total > 0) {
+        return total;
+    }
+    const prompt = await fetchOtelMetricTotal({
+        metric: 'agent_runtimes.prompt.turn.prompt_tokens',
+        serviceName,
+        runUrl,
+        apiKey,
+        limit,
+    });
+    const completion = await fetchOtelMetricTotal({
+        metric: 'agent_runtimes.prompt.turn.completion_tokens',
+        serviceName,
+        runUrl,
+        apiKey,
+        limit,
+    });
+    return prompt + completion;
+}
+export function useOtelTotalTokens({ serviceName, runUrl, apiKey, limit = 500, }) {
+    const [tokensLabel, setTokensLabel] = useState('-');
+    useEffect(() => {
+        let cancelled = false;
+        const load = async () => {
+            try {
+                const total = await fetchOtelTotalTokens({
+                    serviceName,
+                    runUrl,
+                    apiKey,
+                    limit,
+                });
+                if (cancelled) {
+                    return;
+                }
+                if (total > 0) {
+                    setTokensLabel(Math.round(total).toLocaleString());
+                }
+                else {
+                    setTokensLabel('-');
+                }
+            }
+            catch {
+                if (!cancelled) {
+                    setTokensLabel('-');
+                }
+            }
+        };
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [apiKey, limit, runUrl, serviceName]);
+    return tokensLabel;
+}

package/lib/hooks/useNotifications.d.ts

@@ -0,0 +1,67 @@
+import type { NotificationFilters, ListAgentEventsParams, CreateAgentEventRequest, UpdateAgentEventRequest } from '../types';
+export declare function useFilteredNotifications(filters?: NotificationFilters): import("@tanstack/react-query").UseQueryResult<import("../types").AgentNotification[], Error>;
+export declare function useUnreadNotificationCount(): import("@tanstack/react-query").UseQueryResult<{
+    count: number;
+}, Error>;
+export declare function useMarkNotificationRead(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useMarkAllNotificationsRead(): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * List events across all agents for the authenticated user.
+ */
+export declare function useAllAgentEvents(params?: Omit<ListAgentEventsParams, 'agent_id'>, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../types").ListAgentEventsResponse, Error>;
+export declare function useAgentEvents(agentId: string, params?: Omit<ListAgentEventsParams, 'agent_id'>, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("../types").ListAgentEventsResponse, Error>;
+export declare function useAgentEvent(agentId: string, eventId?: string): import("@tanstack/react-query").UseQueryResult<import("../types").GetAgentEventResponse, Error>;
+export declare function useCreateAgentEvent(): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+    event: import("../types").AgentEvent;
+}, Error, CreateAgentEventRequest, unknown>;
+export declare function useUpdateAgentEvent(agentId: string): import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+    eventId: string;
+    payload: UpdateAgentEventRequest;
+}, unknown>;
+export declare function useDeleteAgentEvent(agentId: string): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+}, Error, string | {
+    eventId: string;
+    eventAgentId?: string;
+}, unknown>;
+export declare function useMarkEventRead(agentId: string): import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+    eventId: string;
+    eventAgentId?: string;
+}, unknown>;
+export declare function useMarkEventUnread(agentId: string): import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+    eventId: string;
+    eventAgentId?: string;
+}, unknown>;
+export declare function useNotifications(agentId: string, filters?: NotificationFilters, eventParams?: Omit<ListAgentEventsParams, 'agent_id'>, eventId?: string): {
+    notificationsQuery: import("@tanstack/react-query").UseQueryResult<import("../types").AgentNotification[], Error>;
+    unreadCountQuery: import("@tanstack/react-query").UseQueryResult<{
+        count: number;
+    }, Error>;
+    markRead: import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+    markAllRead: import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+    eventsQuery: import("@tanstack/react-query").UseQueryResult<import("../types").ListAgentEventsResponse, Error>;
+    eventQuery: import("@tanstack/react-query").UseQueryResult<import("../types").GetAgentEventResponse, Error>;
+    createEvent: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+        event: import("../types").AgentEvent;
+    }, Error, CreateAgentEventRequest, unknown>;
+    updateEvent: import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+        eventId: string;
+        payload: UpdateAgentEventRequest;
+    }, unknown>;
+    deleteEvent: import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+    }, Error, string | {
+        eventId: string;
+        eventAgentId?: string;
+    }, unknown>;
+    markEventRead: import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+        eventId: string;
+        eventAgentId?: string;
+    }, unknown>;
+    markEventUnread: import("@tanstack/react-query").UseMutationResult<import("../types").GetAgentEventResponse, Error, {
+        eventId: string;
+        eventAgentId?: string;
+    }, unknown>;
+};

package/lib/hooks/useNotifications.js

@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Agent notification hooks.
+ *
+ * @module hooks/useNotifications
+ */
+import { useMemo } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useCoreStore, useIAMStore } from '@datalayer/core/lib/state';
+import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
+import { events, notifications } from '../api';
+// ─── Auth helpers ────────────────────────────────────────────────────
+function useAuthToken() {
+    const token = useIAMStore((s) => s.token);
+    return token ?? '';
+}
+function useBaseUrl() {
+    const config = useCoreStore((s) => s.configuration);
+    return config?.aiagentsRunUrl ?? DEFAULT_SERVICE_URLS.AI_AGENTS;
+}
+// ─── Base hooks ──────────────────────────────────────────────────────
+export function useFilteredNotifications(filters) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    return useQuery({
+        queryKey: ['agent-notifications', filters],
+        queryFn: () => notifications.getNotifications(token, filters, baseUrl),
+        enabled: !!token,
+        staleTime: 10_000,
+    });
+}
+export function useUnreadNotificationCount() {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    return useQuery({
+        queryKey: ['agent-notifications', 'unread-count'],
+        queryFn: () => notifications.getUnreadCount(token, baseUrl),
+        enabled: !!token,
+        staleTime: 5_000,
+    });
+}
+export function useMarkNotificationRead() {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (id) => notifications.markNotificationRead(token, id, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-notifications'] });
+        },
+    });
+}
+export function useMarkAllNotificationsRead() {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: () => notifications.markAllRead(token, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-notifications'] });
+        },
+    });
+}
+// ─── Event hooks ─────────────────────────────────────────────────────
+/**
+ * List events across all agents for the authenticated user.
+ */
+export function useAllAgentEvents(params, enabled = true) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    return useQuery({
+        queryKey: ['agent-events', params],
+        queryFn: () => events.listAllEvents(token, params ?? {}, baseUrl),
+        enabled: !!token && enabled,
+        staleTime: 10_000,
+    });
+}
+export function useAgentEvents(agentId, params, enabled = true) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    return useQuery({
+        queryKey: ['agent-events', agentId, params],
+        queryFn: () => events.listEvents(token, agentId, params ?? {}, baseUrl),
+        enabled: !!token && !!agentId && enabled,
+        staleTime: 10_000,
+    });
+}
+export function useAgentEvent(agentId, eventId) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    return useQuery({
+        queryKey: ['agent-events', agentId, eventId],
+        queryFn: () => events.getEvent(token, agentId, eventId, baseUrl),
+        enabled: !!token && !!agentId && !!eventId,
+        staleTime: 10_000,
+    });
+}
+export function useCreateAgentEvent() {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload) => events.createEvent(token, payload, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-events'] });
+        },
+    });
+}
+export function useUpdateAgentEvent(agentId) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ eventId, payload, }) => events.updateEvent(token, agentId, eventId, payload, baseUrl),
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: ['agent-events'] });
+            queryClient.invalidateQueries({
+                queryKey: ['agent-events', agentId, variables.eventId],
+            });
+        },
+    });
+}
+export function useDeleteAgentEvent(agentId) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (payload) => {
+            const eventId = typeof payload === 'string' ? payload : payload.eventId;
+            const eventAgentId = typeof payload === 'string' ? undefined : payload.eventAgentId;
+            const resolvedAgentId = eventAgentId || agentId;
+            return events.deleteEvent(token, resolvedAgentId, eventId, baseUrl);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-events'] });
+        },
+    });
+}
+export function useMarkEventRead(agentId) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ eventId, eventAgentId, }) => {
+            const resolvedAgentId = eventAgentId || agentId;
+            return events.markEventRead(token, resolvedAgentId, eventId, baseUrl);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-events'] });
+        },
+    });
+}
+export function useMarkEventUnread(agentId) {
+    const token = useAuthToken();
+    const baseUrl = useBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ eventId, eventAgentId, }) => {
+            const resolvedAgentId = eventAgentId || agentId;
+            return events.markEventUnread(token, resolvedAgentId, eventId, baseUrl);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['agent-events'] });
+        },
+    });
+}
+// ─── Composite hook ──────────────────────────────────────────────────
+export function useNotifications(agentId, filters, eventParams, eventId) {
+    const notificationsQuery = useFilteredNotifications(filters);
+    const unreadCountQuery = useUnreadNotificationCount();
+    const markRead = useMarkNotificationRead();
+    const markAllRead = useMarkAllNotificationsRead();
+    const eventsQuery = useAgentEvents(agentId, eventParams);
+    const eventQuery = useAgentEvent(agentId, eventId);
+    const createEvent = useCreateAgentEvent();
+    const updateEvent = useUpdateAgentEvent(agentId);
+    const deleteEvent = useDeleteAgentEvent(agentId);
+    const markEventRead = useMarkEventRead(agentId);
+    const markEventUnread = useMarkEventUnread(agentId);
+    return useMemo(() => ({
+        notificationsQuery,
+        unreadCountQuery,
+        markRead,
+        markAllRead,
+        eventsQuery,
+        eventQuery,
+        createEvent,
+        updateEvent,
+        deleteEvent,
+        markEventRead,
+        markEventUnread,
+    }), [
+        notificationsQuery,
+        unreadCountQuery,
+        markRead,
+        markAllRead,
+        eventsQuery,
+        eventQuery,
+        createEvent,
+        updateEvent,
+        deleteEvent,
+        markEventRead,
+        markEventUnread,
+    ]);
+}

package/lib/hooks/useSandbox.d.ts

@@ -0,0 +1,12 @@
+import type { SandboxStatusData } from '../types/context';
+/**
+ * Hook to poll sandbox execution status from the backend.
+ * Returns whether a sandbox is available and if code is currently executing.
+ */
+export declare function useSandbox(enabled: boolean, configEndpoint?: string, authToken?: string): import("@tanstack/query-core").QueryObserverRefetchErrorResult<SandboxStatusData, Error> | import("@tanstack/query-core").QueryObserverSuccessResult<SandboxStatusData, Error> | import("@tanstack/query-core").QueryObserverLoadingErrorResult<SandboxStatusData, Error> | import("@tanstack/query-core").QueryObserverPendingResult<SandboxStatusData, Error> | import("@tanstack/query-core").QueryObserverPlaceholderResult<SandboxStatusData, Error> | {
+    data: undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: null;
+    refetch: () => Promise<any>;
+};

package/lib/hooks/useSandbox.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useContext } from 'react';
+import { useQuery, QueryClientContext } from '@tanstack/react-query';
+import { getApiBaseFromConfig } from '../utils';
+/**
+ * Hook to poll sandbox execution status from the backend.
+ * Returns whether a sandbox is available and if code is currently executing.
+ */
+export function useSandbox(enabled, configEndpoint, authToken) {
+    const queryClient = useContext(QueryClientContext);
+    if (!queryClient) {
+        return {
+            data: undefined,
+            isLoading: false,
+            isError: false,
+            error: null,
+            refetch: () => Promise.resolve({}),
+        };
+    }
+    const statusUrl = configEndpoint
+        ? `${getApiBaseFromConfig(configEndpoint)}/configure/sandbox-status`
+        : undefined;
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useQuery({
+        queryKey: ['sandbox-status', statusUrl],
+        queryFn: async () => {
+            if (!statusUrl) {
+                throw new Error('No sandbox status URL available');
+            }
+            const headers = { 'Content-Type': 'application/json' };
+            if (authToken) {
+                headers['Authorization'] = `Bearer ${authToken}`;
+            }
+            const response = await fetch(statusUrl, { headers });
+            if (!response.ok) {
+                throw new Error(`Sandbox status fetch failed: ${response.statusText}`);
+            }
+            return response.json();
+        },
+        enabled: enabled && !!statusUrl,
+        refetchInterval: query => (query.state.status === 'error' ? false : 2_000),
+        refetchOnMount: 'always',
+        staleTime: 0,
+        retry: 1,
+    });
+}

package/lib/hooks/useSkills.d.ts

@@ -0,0 +1,13 @@
+import type { SkillsResponse } from '../types/skills';
+/**
+ * Hook to fetch available skills from backend.
+ */
+export declare function useSkills(enabled: boolean, baseEndpoint?: string, authToken?: string): import("@tanstack/query-core").QueryObserverRefetchErrorResult<SkillsResponse, Error> | import("@tanstack/query-core").QueryObserverSuccessResult<SkillsResponse, Error> | import("@tanstack/query-core").QueryObserverLoadingErrorResult<SkillsResponse, Error> | import("@tanstack/query-core").QueryObserverPendingResult<SkillsResponse, Error> | import("@tanstack/query-core").QueryObserverPlaceholderResult<SkillsResponse, Error> | {
+    data: undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: null;
+    refetch: () => Promise<{
+        data: undefined;
+    }>;
+};

package/lib/hooks/useSkills.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useContext } from 'react';
+import { useQuery, QueryClientContext } from '@tanstack/react-query';
+/**
+ * Hook to fetch available skills from backend.
+ */
+export function useSkills(enabled, baseEndpoint, authToken) {
+    const queryClient = useContext(QueryClientContext);
+    if (!queryClient) {
+        return {
+            data: undefined,
+            isLoading: false,
+            isError: false,
+            error: null,
+            refetch: () => Promise.resolve({ data: undefined }),
+        };
+    }
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useQuery({
+        queryFn: async () => {
+            if (!baseEndpoint) {
+                return { skills: [], total: 0 };
+            }
+            // Derive skills endpoint from config endpoint.
+            const skillsEndpoint = baseEndpoint.replace('/configure', '/skills');
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (authToken) {
+                headers['Authorization'] = `Bearer ${authToken}`;
+            }
+            const response = await fetch(skillsEndpoint, { headers });
+            if (!response.ok) {
+                throw new Error(`Skills fetch failed: ${response.statusText}`);
+            }
+            return response.json();
+        },
+        queryKey: ['skills', baseEndpoint || 'jupyter'],
+        enabled,
+        staleTime: 5 * 60 * 1000,
+        retry: 1,
+    });
+}

package/lib/hooks/useToolApprovals.d.ts

@@ -0,0 +1,45 @@
+import type { ToolApprovalFilters } from '../types/tool-approvals';
+export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<import("../types").ToolApproval[], Error>;
+export declare function usePendingApprovalCount(): import("@tanstack/react-query").UseQueryResult<{
+    count: number;
+}, Error>;
+export declare function useApproveToolRequest(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+    note?: string;
+}, unknown>;
+export declare function useRejectToolRequest(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+    note?: string;
+}, unknown>;
+export declare function useMarkToolApprovalRead(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+}, unknown>;
+export declare function useMarkToolApprovalUnread(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+}, unknown>;
+export declare function useDeleteToolApproval(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    id: string;
+}, unknown>;
+export declare function useToolApprovals(filters?: ToolApprovalFilters): {
+    approvalsQuery: import("@tanstack/react-query").UseQueryResult<import("../types").ToolApproval[], Error>;
+    pendingCountQuery: import("@tanstack/react-query").UseQueryResult<{
+        count: number;
+    }, Error>;
+    approve: import("@tanstack/react-query").UseMutationResult<void, Error, {
+        id: string;
+        note?: string;
+    }, unknown>;
+    reject: import("@tanstack/react-query").UseMutationResult<void, Error, {
+        id: string;
+        note?: string;
+    }, unknown>;
+    markRead: import("@tanstack/react-query").UseMutationResult<void, Error, {
+        id: string;
+    }, unknown>;
+    markUnread: import("@tanstack/react-query").UseMutationResult<void, Error, {
+        id: string;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<void, Error, {
+        id: string;
+    }, unknown>;
+};

package/lib/hooks/useToolApprovals.js

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Agent tool approval hooks.
+ *
+ * @module hooks/useToolApprovals
+ */
+import { useMemo } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useCoreStore, useIAMStore } from '@datalayer/core/lib/state';
+import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
+import { toolApprovals } from '../api';
+// ─── Auth helpers ────────────────────────────────────────────────────
+function useDashboardAuthToken() {
+    const token = useIAMStore((s) => s.token);
+    return token ?? '';
+}
+function useDashboardBaseUrl() {
+    const config = useCoreStore((s) => s.configuration);
+    return config?.aiagentsRunUrl ?? DEFAULT_SERVICE_URLS.AI_AGENTS;
+}
+// ─── Base hooks ──────────────────────────────────────────────────────
+export function useToolApprovalsQuery(filters) {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    return useQuery({
+        queryKey: ['tool-approvals', filters],
+        queryFn: () => toolApprovals.getToolApprovals(token, filters, baseUrl),
+        enabled: !!token,
+        staleTime: 10_000,
+    });
+}
+export function usePendingApprovalCount() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    return useQuery({
+        queryKey: ['tool-approvals', 'pending-count'],
+        queryFn: () => toolApprovals.getPendingApprovalCount(token, baseUrl),
+        enabled: !!token,
+        staleTime: 5_000,
+    });
+}
+export function useApproveToolRequest() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, note }) => toolApprovals.approveToolRequest(token, id, note, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
+        },
+    });
+}
+export function useRejectToolRequest() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, note }) => toolApprovals.rejectToolRequest(token, id, note, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
+        },
+    });
+}
+export function useMarkToolApprovalRead() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id }) => toolApprovals.markToolApprovalRead(token, id, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
+        },
+    });
+}
+export function useMarkToolApprovalUnread() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id }) => toolApprovals.markToolApprovalUnread(token, id, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
+        },
+    });
+}
+export function useDeleteToolApproval() {
+    const token = useDashboardAuthToken();
+    const baseUrl = useDashboardBaseUrl();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id }) => toolApprovals.deleteToolApproval(token, id, baseUrl),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
+        },
+    });
+}
+// ─── Composite hook ──────────────────────────────────────────────────
+export function useToolApprovals(filters) {
+    const approvalsQuery = useToolApprovalsQuery(filters);
+    const pendingQuery = usePendingApprovalCount();
+    const approve = useApproveToolRequest();
+    const reject = useRejectToolRequest();
+    const markRead = useMarkToolApprovalRead();
+    const markUnread = useMarkToolApprovalUnread();
+    const remove = useDeleteToolApproval();
+    return useMemo(() => ({
+        approvalsQuery,
+        pendingCountQuery: pendingQuery,
+        approve,
+        reject,
+        markRead,
+        markUnread,
+        remove,
+    }), [
+        approvalsQuery,
+        pendingQuery,
+        approve,
+        reject,
+        markRead,
+        markUnread,
+        remove,
+    ]);
+}