@elevasis/ui 1.3.0 → 1.3.1

package/dist/{chunk-BZTA7IIL.js → chunk-A3MCANC6.js}

@@ -1,7 +1,11 @@
+import { useSupabase } from './chunk-JGJSZ3UE.js';
 import { UuidSchema, ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema } from './chunk-BLO4SISK.js';
+import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
+import { useStableAccessToken } from './chunk-FWZJH3TL.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
 import { z } from 'zod';
+import { useCallback, useState, useEffect, useMemo, useId, useRef } from 'react';
 
 // src/hooks/executions/queryKeys.ts
 var executionsKeys = {
@@ -658,6 +662,43 @@ function useExecutionHealth({ timeRange }) {
     // 30s monitoring stale time
   });
 }
+function useErrorNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback(
+    (error) => {
+      adapter.apiError(error);
+    },
+    [adapter]
+  );
+}
+function useSuccessNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.success(title, message), [adapter]);
+}
+function useWarningNotification() {
+  const adapter = useNotificationAdapter();
+  return useCallback((title, message) => adapter.warning(title, message), [adapter]);
+}
+function useBatchDelete(tableName, invalidateQueryKeys) {
+  const supabase = useSupabase();
+  const queryClient = useQueryClient();
+  const adapter = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async (ids) => {
+      if (ids.length === 0) return;
+      const { error } = await supabase.from(tableName).delete().in("id", ids);
+      if (error) throw error;
+    },
+    onSuccess: () => {
+      for (const key of invalidateQueryKeys) {
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+    },
+    onError: (err) => {
+      adapter.apiError(err);
+    }
+  });
+}
 
 // src/hooks/observability/queryKeys.ts
 var observabilityKeys = {
@@ -1063,5 +1104,258 @@ function useDeleteSchedule() {
     }
   });
 }
+function usePaginationState(pageSize, resetDeps, total) {
+  const [page, setPage] = useState(1);
+  useEffect(() => {
+    if (resetDeps) {
+      setPage(1);
+    }
+  }, resetDeps ?? []);
+  useEffect(() => {
+    if (total === void 0) return;
+    const lastPage = Math.max(1, Math.ceil(total / pageSize));
+    if (page > lastPage) {
+      setPage(lastPage);
+    }
+  }, [total, pageSize]);
+  return useMemo(
+    () => ({
+      page,
+      setPage,
+      offset: (page - 1) * pageSize,
+      totalPages: (total2) => Math.ceil(total2 / pageSize)
+    }),
+    [page, pageSize]
+  );
+}
+function useTableSelection(items, allItems) {
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const pageIds = useMemo(() => new Set(items.map((i) => i.id)), [items]);
+  useEffect(() => {
+    setSelectedIds((prev) => {
+      const validIds = allItems ? new Set(allItems.map((i) => i.id)) : pageIds;
+      const next = new Set([...prev].filter((id) => validIds.has(id)));
+      return next.size === prev.size ? prev : next;
+    });
+  }, [allItems, pageIds]);
+  const toggle = useCallback((id) => {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+  const togglePage = useCallback(() => {
+    setSelectedIds((prev) => {
+      const allPageSelected = items.every((i) => prev.has(i.id));
+      const next = new Set(prev);
+      if (allPageSelected) {
+        for (const item of items) next.delete(item.id);
+      } else {
+        for (const item of items) next.add(item.id);
+      }
+      return next;
+    });
+  }, [items]);
+  const clear = useCallback(() => setSelectedIds(/* @__PURE__ */ new Set()), []);
+  const isPageAllSelected = items.length > 0 && items.every((i) => selectedIds.has(i.id));
+  const isPagePartiallySelected = !isPageAllSelected && items.some((i) => selectedIds.has(i.id));
+  return {
+    selectedIds,
+    toggle,
+    togglePage,
+    clear,
+    isPageAllSelected,
+    isPagePartiallySelected,
+    selectedCount: selectedIds.size,
+    isSelected: (id) => selectedIds.has(id)
+  };
+}
+function useTableSort(defaultColumn, defaultDirection = "desc") {
+  const [sort, setSort] = useState({ column: defaultColumn, direction: defaultDirection });
+  const toggleSort = useCallback((column) => {
+    setSort((prev) => {
+      if (prev.column === column) {
+        return { column, direction: prev.direction === "asc" ? "desc" : "asc" };
+      }
+      return { column, direction: "desc" };
+    });
+  }, []);
+  return { sort, toggleSort };
+}
+function sortData(data, sort, accessors) {
+  const accessor = accessors[sort.column];
+  if (!accessor) return data;
+  return [...data].sort((a, b) => {
+    const aVal = accessor(a);
+    const bVal = accessor(b);
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    let comparison = 0;
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      comparison = aVal.localeCompare(bVal);
+    } else if (typeof aVal === "number" && typeof bVal === "number") {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    return sort.direction === "asc" ? comparison : -comparison;
+  });
+}
+function useSortedData(data, defaultColumn, accessors, defaultDirection = "desc") {
+  const { sort, toggleSort } = useTableSort(defaultColumn, defaultDirection);
+  const sorted = useMemo(() => sortData(data, sort, accessors), [data, sort, accessors]);
+  return { sorted, sort, toggleSort };
+}
+function createUseFeatureAccess({
+  useInitialization,
+  useOrganization,
+  optInFeatures = [],
+  getCoursesByGroup = () => []
+}) {
+  return function useFeatureAccess() {
+    const { profile, organizationReady } = useInitialization();
+    const { currentMembership } = useOrganization();
+    const { orgConfig, membershipConfig } = useMemo(() => {
+      const organizationConfig = currentMembership?.organization?.config;
+      const memberConfig = currentMembership?.config;
+      return { orgConfig: organizationConfig, membershipConfig: memberConfig };
+    }, [currentMembership]);
+    const userConfig = profile?.config;
+    const checkFeature = useCallback(
+      (featureKey) => {
+        const key = featureKey;
+        const orgValue = orgConfig?.features?.[key];
+        if (!profile?.is_platform_admin) {
+          const membershipValue = membershipConfig?.features?.[key];
+          if (membershipValue === false) return { allowed: false, restrictedBy: "membership" };
+          if (membershipValue === true) return { allowed: true, restrictedBy: null };
+        }
+        if (optInFeatures.includes(featureKey)) {
+          return orgValue === true ? { allowed: true, restrictedBy: null } : { allowed: false, restrictedBy: "org" };
+        }
+        return orgValue === false ? { allowed: false, restrictedBy: "org" } : { allowed: true, restrictedBy: null };
+      },
+      [profile?.is_platform_admin, membershipConfig, orgConfig]
+    );
+    const hasFeature = useCallback((featureKey) => checkFeature(featureKey).allowed, [checkFeature]);
+    const hasTrainingAccess = useCallback(() => {
+      if (profile?.is_platform_admin) return true;
+      return userConfig?.training?.enabled ?? true;
+    }, [profile?.is_platform_admin, userConfig?.training?.enabled]);
+    const getAllowedCourses = useCallback(() => {
+      if (userConfig?.training?.allowed_courses?.length) {
+        return userConfig.training.allowed_courses;
+      }
+      return null;
+    }, [userConfig?.training?.allowed_courses]);
+    const getResolvedCourseAccess = useCallback(() => {
+      if (profile?.is_platform_admin) return null;
+      const orgGroups = orgConfig?.training?.allowed_course_groups ?? [];
+      const userGroups = userConfig?.training?.allowed_course_groups ?? [];
+      const userCourses = userConfig?.training?.allowed_courses ?? [];
+      if (!orgGroups.length && !userGroups.length && !userCourses.length) return null;
+      const foundationCourses = getCoursesByGroup("foundation");
+      const orgCourseSlugs = orgGroups.flatMap(getCoursesByGroup);
+      const userGroupCourseSlugs = userGroups.flatMap(getCoursesByGroup);
+      return [.../* @__PURE__ */ new Set([...foundationCourses, ...orgCourseSlugs, ...userGroupCourseSlugs, ...userCourses])];
+    }, [
+      profile?.is_platform_admin,
+      orgConfig?.training?.allowed_course_groups,
+      userConfig?.training?.allowed_course_groups,
+      userConfig?.training?.allowed_courses
+    ]);
+    const hasAccessToCourse = useCallback(
+      (courseSlug) => {
+        const resolved = getResolvedCourseAccess();
+        if (resolved === null) return true;
+        return resolved.includes(courseSlug);
+      },
+      [getResolvedCourseAccess]
+    );
+    const getEnabledGroups = useCallback(() => {
+      const orgGroups = orgConfig?.training?.allowed_course_groups ?? [];
+      const userGroups = userConfig?.training?.allowed_course_groups ?? [];
+      return [.../* @__PURE__ */ new Set(["foundation", ...orgGroups, ...userGroups])];
+    }, [orgConfig?.training?.allowed_course_groups, userConfig?.training?.allowed_course_groups]);
+    return {
+      orgConfig,
+      membershipConfig,
+      userConfig,
+      hasFeature,
+      checkFeature,
+      hasTrainingAccess,
+      getAllowedCourses,
+      getResolvedCourseAccess,
+      hasAccessToCourse,
+      getEnabledGroups,
+      isReady: organizationReady
+    };
+  };
+}
+function useSSEConnection({
+  manager,
+  connectionKey,
+  url,
+  enabled = true,
+  headers,
+  onmessage,
+  onopen,
+  onerror,
+  onclose
+}) {
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState(null);
+  const getAccessToken = useStableAccessToken();
+  const subscriberId = useId();
+  const onmessageRef = useRef(onmessage);
+  const onopenRef = useRef(onopen);
+  const onerrorRef = useRef(onerror);
+  const oncloseRef = useRef(onclose);
+  const headersRef = useRef(headers);
+  onmessageRef.current = onmessage;
+  onopenRef.current = onopen;
+  onerrorRef.current = onerror;
+  oncloseRef.current = onclose;
+  headersRef.current = headers;
+  useEffect(() => {
+    if (!enabled) return;
+    const unsubscribe = manager.subscribe(connectionKey, subscriberId, {
+      url,
+      getToken: getAccessToken,
+      headers: headersRef.current ?? {},
+      onopen(response) {
+        if (response.ok) {
+          setConnected(true);
+          setError(null);
+        }
+        const customError = onopenRef.current?.(response);
+        if (customError) setError(customError);
+      },
+      onmessage(event) {
+        if (!event.data || event.data.trim() === "") return;
+        onmessageRef.current(event.data);
+      },
+      onerror(err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        setConnected(false);
+        setError(msg);
+        onerrorRef.current?.(err instanceof Error ? err : new Error(msg));
+      },
+      onclose() {
+        setConnected(false);
+        oncloseRef.current?.();
+      }
+    });
+    return () => {
+      unsubscribe();
+      setConnected(false);
+      setError(null);
+    };
+  }, [enabled, connectionKey, url, subscriberId, getAccessToken, manager]);
+  return { connected, error };
+}
 
-export { OperationsService, executionsKeys, observabilityKeys, scheduleKeys, useActivities, useActivityTrend, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule };
+export { OperationsService, createUseFeatureAccess, executionsKeys, observabilityKeys, scheduleKeys, sortData, useActivities, useActivityTrend, useBatchDelete, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePaginationState, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useSSEConnection, useSortedData, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification };

package/dist/chunk-FWZJH3TL.js

@@ -0,0 +1,13 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useRef, useCallback } from 'react';
+
+function useStableAccessToken() {
+  const { getAccessToken } = useAuthContext();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  return useCallback(() => {
+    return getAccessTokenRef.current();
+  }, []);
+}
+
+export { useStableAccessToken };

package/dist/{chunk-EZMRFWZQ.js → chunk-JBFFCZI4.js}

@@ -1,4 +1,4 @@
-import { useUserProfile } from './chunk-4KAG5U7A.js';
+import { useUserProfile } from './chunk-L2CM2CUA.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { useState, useRef, useEffect, useCallback } from 'react';
 import { Button, Loader, Menu, Text, Badge } from '@mantine/core';

package/dist/chunk-JGJSZ3UE.js

@@ -0,0 +1,47 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { createClient } from '@supabase/supabase-js';
+import { useMemo } from 'react';
+
+function getSupabaseConfig() {
+  const url = import.meta.env?.VITE_SUPABASE_URL;
+  const anonKey = import.meta.env?.VITE_SUPABASE_ANON_KEY;
+  if (!url || !anonKey) {
+    throw new Error("Missing Supabase environment variables (VITE_SUPABASE_URL, VITE_SUPABASE_ANON_KEY)");
+  }
+  return { url, anonKey };
+}
+var _supabase = null;
+function getSupabaseClient() {
+  if (!_supabase) {
+    const { url, anonKey } = getSupabaseConfig();
+    _supabase = createClient(url, anonKey);
+  }
+  return _supabase;
+}
+var useSupabase = () => {
+  const { getAccessToken } = useAuthContext();
+  const { url, anonKey } = getSupabaseConfig();
+  return useMemo(
+    () => createClient(url, anonKey, {
+      global: {
+        headers: {
+          // Additional headers if needed
+        }
+      },
+      accessToken: async () => {
+        try {
+          const token = await getAccessToken();
+          if (!token) {
+            return null;
+          }
+          return token;
+        } catch {
+          return null;
+        }
+      }
+    }),
+    [getAccessToken, url, anonKey]
+  );
+};
+
+export { getSupabaseClient, useSupabase };

package/dist/{chunk-4KAG5U7A.js → chunk-L2CM2CUA.js}

@@ -135,8 +135,6 @@ function useProfile() {
 }
 function ProfileProvider({ children }) {
   const value = useUserProfile();
-  if (!value.loading && value.profile) console.log("[ProfileProvider] ready, profile:", value.profile.id);
-  if (!value.loading && value.error) console.log("[ProfileProvider] error:", value.error.message);
   return createElement(ProfileContext.Provider, { value }, children);
 }
 

package/dist/{chunk-QQOLC46E.js → chunk-NEK6JKPW.js}

@@ -1,5 +1,5 @@
+import { useProfile } from './chunk-L2CM2CUA.js';
 import { useOrganization } from './chunk-DD3CCMCZ.js';
-import { useProfile } from './chunk-4KAG5U7A.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { createContext, useContext, useMemo, useCallback, createElement } from 'react';
 

package/dist/{chunk-SITSZUFW.js → chunk-PVVQTENF.js}

@@ -1,4 +1,4 @@
-import { useUserProfile } from './chunk-4KAG5U7A.js';
+import { useUserProfile } from './chunk-L2CM2CUA.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { useMemo, useCallback } from 'react';
 

package/dist/{chunk-PCBXNHKY.js → chunk-TZPAA4RC.js}

@@ -1,4 +1,4 @@
-import { ElevasisCoreProvider } from './chunk-OLD3NQLI.js';
+import { ElevasisCoreProvider } from './chunk-72HOBFMP.js';
 import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-4VGWQ5AN.js';
 import { useMemo, useEffect } from 'react';
 import { Tooltip, Text, Tabs, Table, Stack, SimpleGrid, Select, Combobox, SegmentedControl, ScrollArea, Paper, Popover, Notification, Modal, Menu, Input, HoverCard, Group, Grid, Flex, Code, Divider, Card, Button, Accordion, createTheme, mergeThemeOverrides, MantineProvider } from '@mantine/core';
@@ -1401,10 +1401,11 @@ var mantineNotificationAdapter = {
   },
   apiError(error) {
     const { message, code, requestId, fields, retryAfter } = getErrorInfo(error);
+    const hasFields = fields && Object.keys(fields).length > 0;
     notifications.show({
       title: getErrorTitle(code),
       message: formatErrorMessage(message, requestId, fields, retryAfter),
-      autoClose: retryAfter ? retryAfter * 1e3 : 5e3,
+      autoClose: retryAfter ? retryAfter * 1e3 : hasFields ? 8e3 : 5e3,
       color: "red",
       position: "top-right"
     });

package/dist/{chunk-FLJXZ7YC.js → chunk-UMXDDEAG.js}

@@ -1,5 +1,5 @@
+import { useProfile } from './chunk-L2CM2CUA.js';
 import { OrganizationContext } from './chunk-DD3CCMCZ.js';
-import { useProfile } from './chunk-4KAG5U7A.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { useState, useRef, useEffect, useCallback, createElement } from 'react';
@@ -54,7 +54,6 @@ function OrganizationProvider({ children }) {
       if (!selected && data.length > 0) {
         selected = data[0];
       }
-      console.log("[OrgProvider] selected:", selected?.organization?.workos_org_id ?? "none");
       if (selected) {
         applyMembership(selected);
       }
@@ -108,7 +107,6 @@ function OrganizationProvider({ children }) {
     applyMembership
   ]);
   useEffect(() => {
-    console.log("[OrgProvider] gate:", { userId: !!user?.id, profileLoaded, initialized: hasInitializedRef.current });
     if (!user?.id || !profileLoaded || hasInitializedRef.current) return;
     fetchAndInitialize();
   }, [user?.id, profileLoaded, fetchAndInitialize]);

package/dist/{chunk-BWCC6ZJC.js → chunk-XLV6LYN2.js}

@@ -1,4 +1,5 @@
 import { APIClientError } from './chunk-4VGWQ5AN.js';
+import { OrganizationContext } from './chunk-DD3CCMCZ.js';
 import { createContext, useContext, useMemo, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -54,7 +55,6 @@ function buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleRespon
     try {
       const token = await getAccessToken();
       const organizationId = getOrganizationId();
-      if (organizationId) console.log("[apiRequest]", endpoint, "org:", organizationId);
       const headers = {
         ...options.body ? { "Content-Type": "application/json" } : {},
         ...token ? { Authorization: `Bearer ${token}` } : {},
@@ -74,7 +74,8 @@ function buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleRespon
       if (response.status === 204) {
         return void 0;
       }
-      return response.json();
+      const data = await response.json();
+      return data;
     } catch (error) {
       if (error instanceof Error && error.message.includes("No access token")) {
         const headers = {
@@ -101,7 +102,10 @@ function buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleRespon
   };
 }
 function useApiClient(apiUrl) {
-  const { getAccessToken, getOrganizationId, isOrganizationReady, onError } = useApiClientContext();
+  const { getAccessToken, getOrganizationId, isOrganizationReady: contextOrgReady, onError } = useApiClientContext();
+  const orgCtx = useContext(OrganizationContext);
+  const orgReady = orgCtx ? !!orgCtx.currentWorkOSOrganizationId && !orgCtx.isInitializing && !orgCtx.isOrgRefreshing : contextOrgReady;
+  const orgInitializing = orgCtx ? orgCtx.isInitializing || orgCtx.isOrgRefreshing : false;
   const handleResponseError = useCallback(
     async (endpoint, response, options) => {
       const errorData = await response.json().catch(() => ({
@@ -132,71 +136,22 @@ function useApiClient(apiUrl) {
   );
   const deferredApiRequest = useCallback(
     async (endpoint, options = {}) => {
-      if (!isOrganizationReady) {
+      if (orgInitializing) {
+        throw new Error("Organization context is still initializing. Please wait.");
+      }
+      if (!orgReady) {
         throw new Error("No organization selected. Please select an organization.");
       }
       return apiRequest(endpoint, options);
     },
-    [apiRequest, isOrganizationReady]
+    [apiRequest, orgInitializing, orgReady]
   );
   return {
     apiRequest,
     deferredApiRequest,
-    isOrganizationReady,
-    isInitializing: false
-  };
-}
-function createUseApiClient(useOrganizations, apiUrl) {
-  return function useApiClientCompat() {
-    const { getAccessToken, getOrganizationId, isOrganizationReady, onError } = useApiClientContext();
-    const { isInitializing, isOrgRefreshing } = useOrganizations();
-    const handleResponseError = useCallback(
-      async (endpoint, response, options) => {
-        const errorData = await response.json().catch(() => ({
-          error: `HTTP ${response.status}`,
-          code: "INTERNAL_SERVER_ERROR"
-        }));
-        if (response.status >= 500 && onError) {
-          onError(endpoint, new Error(errorData.error), {
-            method: options.method || "GET",
-            statusCode: response.status,
-            requestId: errorData.requestId
-          });
-        }
-        throw new APIClientError(
-          errorData.error,
-          errorData.code,
-          response.status,
-          errorData.requestId,
-          errorData.fields,
-          errorData.retryAfter
-        );
-      },
-      [onError]
-    );
-    const apiRequest = useCallback(
-      (endpoint, options = {}) => buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleResponseError)(endpoint, options),
-      [getAccessToken, getOrganizationId, handleResponseError]
-    );
-    const deferredApiRequest = useCallback(
-      async (endpoint, options = {}) => {
-        if (isInitializing || isOrgRefreshing) {
-          throw new Error("Organization context is still initializing. Please wait.");
-        }
-        if (!isOrganizationReady) {
-          throw new Error("No organization selected. Please select an organization.");
-        }
-        return apiRequest(endpoint, options);
-      },
-      [apiRequest, isInitializing, isOrgRefreshing, isOrganizationReady]
-    );
-    return {
-      apiRequest,
-      deferredApiRequest,
-      isOrganizationReady,
-      isInitializing: isInitializing || isOrgRefreshing
-    };
+    isOrganizationReady: orgReady,
+    isInitializing: orgInitializing
   };
 }
 
-export { ApiClientProvider, createUseApiClient, useApiClient, useApiClientContext };
+export { ApiClientProvider, useApiClient, useApiClientContext };