@iblai/data-layer 1.18.1 → 1.19.1

package/dist/index.js

@@ -48424,6 +48424,396 @@ const USER_CHAT_HISTORY_REPORT_ACTIVE_STATES = [
     'storing',
 ];
 
+const USER_LLM_USAGE_REDUCER_PATH = 'userLlmUsageApiSlice';
+const USER_LLM_USAGE_QUERY_KEYS = {
+    GET_USER_LLM_USAGE: () => ['USER_LLM_USAGE'],
+};
+/** Upstream cap on `limit`. */
+const USER_LLM_USAGE_MAX_LIMIT = 1000;
+/**
+ * The same llm-usage endpoint the admin analytics use, always scoped to one
+ * `username`. The path builder is the admin one, so array params (`measures`)
+ * serialize identically — comma-joined — and empty values are dropped the
+ * same way.
+ */
+const USER_LLM_USAGE_ENDPOINTS = {
+    GET_USER_LLM_USAGE: {
+        service: exports.SERVICES.DM,
+        path: ({ resource, ...rest }) => NON_AI_ANALYTICS_ENDPOINTS.GET_LLM_USAGE.path(resource, rest),
+    },
+};
+/**
+ * User-safe fallbacks per error kind. None of them echo the backend's detail,
+ * so a 403 or 404 never tells the viewer whether another user or tenant exists.
+ */
+const USER_LLM_USAGE_ERROR_MESSAGES = {
+    forbidden: 'Usage data is not available for this account.',
+    not_found: 'Usage data is not available for this account.',
+    unauthorized: 'Your session has expired. Sign in again to see your usage.',
+    unavailable: 'Usage data is temporarily unavailable. Please try again later.',
+    invalid_params: 'This usage request is not supported.',
+    unknown: 'Something went wrong while loading your usage.',
+};
+
+const RESOURCES = ['metrics', 'traces', 'observations'];
+/** Params the backend refuses on the observations resource. */
+const NOT_ON_OBSERVATIONS = ['session_id', 'mentor_unique_id'];
+const isSet = (value) => value !== undefined && value !== null && value !== '';
+/**
+ * Runtime twin of the param types, for params assembled dynamically where the
+ * compiler cannot see them. Runs before every request, so an invalid
+ * combination never leaves the browser.
+ */
+function validateUserLlmUsageParams(params) {
+    if (!params || typeof params !== 'object') {
+        return { ok: false, reason: 'params must be an object' };
+    }
+    const p = params;
+    if (!RESOURCES.includes(p.resource)) {
+        return { ok: false, reason: `unknown resource "${String(p.resource)}"` };
+    }
+    if (typeof p.platform_key !== 'string' || p.platform_key.trim() === '') {
+        return { ok: false, reason: 'platform_key is required' };
+    }
+    if (typeof p.username !== 'string' || p.username.trim() === '') {
+        // Without it the backend falls back to the caller's own scope, which for
+        // an admin is every user on the platform.
+        return { ok: false, reason: 'username is required' };
+    }
+    if (p.resource === 'observations') {
+        const offending = NOT_ON_OBSERVATIONS.find((key) => isSet(p[key]));
+        if (offending) {
+            return { ok: false, reason: `${offending} is not allowed on observations` };
+        }
+    }
+    const hasDates = isSet(p.start_date) || isSet(p.end_date);
+    if (p.date_filter === 'custom') {
+        if (!isSet(p.start_date) || !isSet(p.end_date)) {
+            return { ok: false, reason: 'a custom range needs both start_date and end_date' };
+        }
+    }
+    else if (hasDates) {
+        return { ok: false, reason: 'start_date/end_date require date_filter "custom"' };
+    }
+    if (isSet(p.limit)) {
+        const limit = Number(p.limit);
+        if (!Number.isInteger(limit) || limit < 1 || limit > USER_LLM_USAGE_MAX_LIMIT) {
+            return { ok: false, reason: `limit must be between 1 and ${USER_LLM_USAGE_MAX_LIMIT}` };
+        }
+    }
+    return { ok: true, params: params };
+}
+const errorFor = (kind, status) => ({
+    kind,
+    ...(status !== undefined && { status }),
+    message: USER_LLM_USAGE_ERROR_MESSAGES[kind],
+});
+/**
+ * Maps whatever a usage query failed with onto a typed, user-safe error.
+ * The backend's own `detail`/`error` text is never carried over.
+ *
+ * A 401 is reported as `unauthorized` for completeness, but it has already
+ * gone through the app's registered auth handler (token refresh, then the
+ * host's 401 handler) inside the base query before it gets here.
+ */
+function normalizeUserLlmUsageError(error) {
+    if (error === undefined || error === null)
+        return null;
+    if (typeof error !== 'object')
+        return errorFor('unknown');
+    const { status, data } = error;
+    if (status === 'CUSTOM_ERROR') {
+        const kind = data === null || data === void 0 ? void 0 : data.kind;
+        return errorFor(kind === 'invalid_params' ? 'invalid_params' : 'unknown', status);
+    }
+    if (status === 'FETCH_ERROR' || status === 'TIMEOUT_ERROR') {
+        return errorFor('unavailable', status);
+    }
+    if (typeof status === 'number') {
+        if (status === 401)
+            return errorFor('unauthorized', status);
+        if (status === 403)
+            return errorFor('forbidden', status);
+        if (status === 404)
+            return errorFor('not_found', status);
+        if (status === 502 || status === 503 || status === 504)
+            return errorFor('unavailable', status);
+        return errorFor('unknown', status);
+    }
+    return errorFor('unknown');
+}
+/**
+ * Wraps the raw response so `data` is always a list. Single-item lookups
+ * (`trace_id`, `observation_id`) come back as one object without `meta`.
+ */
+function toUserLlmUsageEnvelope(raw, resource) {
+    const body = (raw && typeof raw === 'object' ? raw : {});
+    const data = Array.isArray(body.data)
+        ? body.data
+        : body.data && typeof body.data === 'object'
+            ? [body.data]
+            : [];
+    const envelope = { resource, data };
+    if (resource !== 'metrics' && body.meta) {
+        envelope.meta = body.meta;
+    }
+    return envelope;
+}
+/**
+ * Empty-state rule shared by every usage hook: paginated resources trust
+ * `meta.totalItems`; metrics (and unpaginated lookups) fall back to the rows.
+ */
+function isUserLlmUsageEmpty(envelope) {
+    if (!envelope)
+        return false;
+    if (envelope.meta && typeof envelope.meta.totalItems === 'number') {
+        return envelope.meta.totalItems === 0;
+    }
+    return envelope.data.length === 0;
+}
+/** Reads a numeric measure (`sum_totalCost`, `avg_latency`, …) off a metrics row. */
+function readMeasure(row, key) {
+    const value = row === null || row === void 0 ? void 0 : row[key];
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    return 0;
+}
+
+/**
+ * One request through the app's standard base query (auth header, token
+ * refresh, registered 401 handler). `iblFetchBaseQuery` throws on HTTP
+ * errors, and a thrown error would reach RTK as a SerializedError with the
+ * status stripped; catching it here keeps `{ status, data }` intact so the
+ * view can tell a 403 from a 404.
+ */
+async function fetchUserLlmUsage(params, api, extraOptions) {
+    const check = validateUserLlmUsageParams(params);
+    if (!check.ok) {
+        return {
+            error: {
+                status: 'CUSTOM_ERROR',
+                error: check.reason,
+                data: { kind: 'invalid_params', error: check.reason },
+            },
+        };
+    }
+    try {
+        const result = await iblFetchBaseQuery({
+            url: USER_LLM_USAGE_ENDPOINTS.GET_USER_LLM_USAGE.path(check.params),
+            service: USER_LLM_USAGE_ENDPOINTS.GET_USER_LLM_USAGE.service,
+        }, api, extraOptions);
+        if ('error' in result && result.error) {
+            return { error: result.error };
+        }
+        return { data: toUserLlmUsageEnvelope(result.data, params.resource) };
+    }
+    catch (error) {
+        return { error: error };
+    }
+}
+/**
+ * Per-user llm-usage queries. Registered in the mentor and skills stores.
+ * Cache entries are keyed on the full param object, so `platform_key`,
+ * `username`, `resource` and every filter take part in the key.
+ */
+const userLlmUsageApiSlice = react.createApi({
+    reducerPath: USER_LLM_USAGE_REDUCER_PATH,
+    baseQuery: iblFakeBaseQuery,
+    tagTypes: [...USER_LLM_USAGE_QUERY_KEYS.GET_USER_LLM_USAGE()],
+    endpoints: (builder) => ({
+        getUserLlmUsageMetrics: builder.query({
+            queryFn: (params, api, extraOptions) => fetchUserLlmUsage(params, api, extraOptions),
+            providesTags: USER_LLM_USAGE_QUERY_KEYS.GET_USER_LLM_USAGE(),
+        }),
+        getUserLlmUsageTraces: builder.query({
+            queryFn: (params, api, extraOptions) => fetchUserLlmUsage(params, api, extraOptions),
+            providesTags: USER_LLM_USAGE_QUERY_KEYS.GET_USER_LLM_USAGE(),
+        }),
+        getUserLlmUsageObservations: builder.query({
+            queryFn: (params, api, extraOptions) => fetchUserLlmUsage(params, api, extraOptions),
+            providesTags: USER_LLM_USAGE_QUERY_KEYS.GET_USER_LLM_USAGE(),
+        }),
+    }),
+});
+const { useGetUserLlmUsageMetricsQuery, useGetUserLlmUsageTracesQuery, useGetUserLlmUsageObservationsQuery, } = userLlmUsageApiSlice;
+
+/** A query needs a platform key and a user; without either it stays idle. */
+const shouldSkip = (params, options) => !!(options === null || options === void 0 ? void 0 : options.skip) || !params || !params.platform_key || !params.username;
+function useDerivedState(query, isIdle) {
+    const { data, error, isLoading, isFetching, refetch } = query;
+    return react$1.useMemo(() => {
+        var _a;
+        const normalized = isIdle ? null : normalizeUserLlmUsageError(error);
+        return {
+            rows: (_a = data === null || data === void 0 ? void 0 : data.data) !== null && _a !== void 0 ? _a : [],
+            meta: data === null || data === void 0 ? void 0 : data.meta,
+            // Only a successful load can be empty: an error or a pending first load
+            // is not "no usage".
+            isEmpty: !isIdle && !normalized && !isLoading && isUserLlmUsageEmpty(data),
+            isIdle,
+            isLoading: !isIdle && isLoading,
+            isFetching: !isIdle && isFetching,
+            error: normalized,
+            refetch: () => {
+                if (!isIdle)
+                    refetch();
+            },
+        };
+    }, [data, error, isLoading, isFetching, refetch, isIdle]);
+}
+/** Any metrics query. Idle until `platform_key` and `username` are set. */
+function useUserLlmUsageMetrics(params, options) {
+    const skip = shouldSkip(params, options);
+    const query$1 = useGetUserLlmUsageMetricsQuery(skip || !params ? query.skipToken : params);
+    return useDerivedState(query$1, skip);
+}
+/** Any traces query. Idle until `platform_key` and `username` are set. */
+function useUserLlmUsageTraces(params, options) {
+    const skip = shouldSkip(params, options);
+    const query$1 = useGetUserLlmUsageTracesQuery(skip || !params ? query.skipToken : params);
+    return useDerivedState(query$1, skip);
+}
+/** Any observations query. Idle until `platform_key` and `username` are set. */
+function useUserLlmUsageObservations(params, options) {
+    const skip = shouldSkip(params, options);
+    const query$1 = useGetUserLlmUsageObservationsQuery(skip || !params ? query.skipToken : params);
+    return useDerivedState(query$1, skip);
+}
+/**
+ * `{ platformKey, username, ...range }` → the wire params, or null while
+ * either identifier is still missing.
+ */
+function scopeToParams(scope) {
+    const { platformKey, username, ...range } = scope;
+    if (!platformKey || !username)
+        return null;
+    return {
+        platform_key: platformKey,
+        username,
+        ...range,
+    };
+}
+// ---------------------------------------------------------------------------
+// Thin wrappers — one per view need. Each is the parameterized hook
+// above with the resource and measures filled in, plus a parsed view of the
+// rows so components never read `sum_totalCost`-style keys themselves.
+// ---------------------------------------------------------------------------
+/** Headline totals for the user: `measures=total_cost,total_tokens,count`, summed. */
+function useUserLlmUsageSummary(scope, options) {
+    const base = scopeToParams(scope);
+    const state = useUserLlmUsageMetrics(base && {
+        ...base,
+        resource: 'metrics',
+        measures: ['total_cost', 'total_tokens', 'count'],
+        aggregation: 'sum',
+    }, options);
+    return react$1.useMemo(() => {
+        const row = state.rows[0];
+        const summary = row
+            ? {
+                totalCost: readMeasure(row, 'sum_totalCost'),
+                totalTokens: readMeasure(row, 'sum_totalTokens'),
+                count: readMeasure(row, 'sum_count'),
+            }
+            : null;
+        // The totals query always answers with one row; a row of zeros is still
+        // "no usage in this range".
+        const isEmpty = state.isEmpty || (!!summary && summary.count === 0 && summary.totalCost === 0);
+        return { ...state, isEmpty, summary };
+    }, [state]);
+}
+/** The user's spend per time bucket (`granularity=day` unless told otherwise). */
+function useUserLlmSpendOverTime(scope, options) {
+    const { granularity = 'day', ...rest } = scope;
+    const base = scopeToParams(rest);
+    const state = useUserLlmUsageMetrics(base && {
+        ...base,
+        resource: 'metrics',
+        measures: ['total_cost'],
+        aggregation: 'sum',
+        granularity,
+    }, options);
+    return react$1.useMemo(() => {
+        const points = state.rows
+            .filter((row) => typeof row.time_dimension === 'string' && row.time_dimension)
+            .map((row) => ({
+            date: String(row.time_dimension).slice(0, 10),
+            totalCost: readMeasure(row, 'sum_totalCost'),
+        }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+        return { ...state, points };
+    }, [state]);
+}
+/** The user's spend and call count per model, most expensive first. */
+function useUserLlmCostByModel(scope, options) {
+    const { limit, ...rest } = scope;
+    const base = scopeToParams(rest);
+    const state = useUserLlmUsageMetrics(base && {
+        ...base,
+        resource: 'metrics',
+        measures: ['total_cost', 'count'],
+        aggregation: 'sum',
+        group_by: 'model',
+        order_by: 'total_cost',
+        direction: 'desc',
+        ...(limit !== undefined && { limit }),
+    }, options);
+    return react$1.useMemo(() => {
+        const models = state.rows
+            .map((row) => ({
+            model: typeof row.providedModelName === 'string' ? row.providedModelName : '',
+            totalCost: readMeasure(row, 'sum_totalCost'),
+            count: readMeasure(row, 'sum_count'),
+        }))
+            .sort((a, b) => b.totalCost - a.totalCost);
+        return { ...state, models };
+    }, [state]);
+}
+/** The user's spend and call count per service (the trace name: chat, memory, …). */
+function useUserLlmCostByService(scope, options) {
+    const base = scopeToParams(scope);
+    const state = useUserLlmUsageMetrics(base && {
+        ...base,
+        resource: 'metrics',
+        measures: ['total_cost', 'count'],
+        aggregation: 'sum',
+        group_by: 'type',
+    }, options);
+    return react$1.useMemo(() => {
+        const services = state.rows
+            .map((row) => ({
+            service: typeof row.traceName === 'string' ? row.traceName : '',
+            totalCost: readMeasure(row, 'sum_totalCost'),
+            count: readMeasure(row, 'sum_count'),
+        }))
+            .sort((a, b) => b.totalCost - a.totalCost);
+        return { ...state, services };
+    }, [state]);
+}
+const USER_LLM_RECENT_ACTIVITY_PAGE_SIZE = 10;
+/** The user's traces, newest first, one page at a time. */
+function useUserLlmRecentActivity(scope, options) {
+    const { page = 1, limit = USER_LLM_RECENT_ACTIVITY_PAGE_SIZE, ...rest } = scope;
+    const base = scopeToParams(rest);
+    return useUserLlmUsageTraces(base && {
+        ...base,
+        resource: 'traces',
+        order_by: 'timestamp',
+        direction: 'desc',
+        page,
+        limit,
+    }, options);
+}
+/** The steps (observations) inside one trace. Idle until a trace is picked. */
+function useUserLlmTraceObservations(scope, options) {
+    const { traceId, limit = 50, ...rest } = scope;
+    const base = scopeToParams(rest);
+    return useUserLlmUsageObservations(base && traceId ? { ...base, resource: 'observations', trace_id: traceId, limit } : null, options);
+}
+
 const mentorReducer = {
     [mentorApiSlice.reducerPath]: mentorApiSlice.reducer,
     [tenantApiSlice.reducerPath]: tenantApiSlice.reducer,
@@ -48486,6 +48876,7 @@ const mentorReducer = {
     [gradingApiSlice.reducerPath]: gradingApiSlice.reducer,
     [spendCapsApiSlice.reducerPath]: spendCapsApiSlice.reducer,
     [userChatHistoryApiSlice.reducerPath]: userChatHistoryApiSlice.reducer,
+    [userLlmUsageApiSlice.reducerPath]: userLlmUsageApiSlice.reducer,
 };
 const mentorMiddleware = [
     mentorApiSlice.middleware,
@@ -48549,6 +48940,7 @@ const mentorMiddleware = [
     gradingApiSlice.middleware,
     spendCapsApiSlice.middleware,
     userChatHistoryApiSlice.middleware,
+    userLlmUsageApiSlice.middleware,
 ];
 
 const skillsReducer = {
@@ -48595,6 +48987,8 @@ const skillsReducer = {
     [chatPrivacyApiSlice.reducerPath]: chatPrivacyApiSlice.reducer,
     [agentSkillsApiSlice.reducerPath]: agentSkillsApiSlice.reducer,
     [userChatHistoryApiSlice.reducerPath]: userChatHistoryApiSlice.reducer,
+    [chatApiSlice.reducerPath]: chatApiSlice.reducer,
+    [userLlmUsageApiSlice.reducerPath]: userLlmUsageApiSlice.reducer,
 };
 const skillsMiddleware = [
     perLearnerApiSlice.middleware,
@@ -48640,6 +49034,8 @@ const skillsMiddleware = [
     chatPrivacyApiSlice.middleware,
     agentSkillsApiSlice.middleware,
     userChatHistoryApiSlice.middleware,
+    chatApiSlice.middleware,
+    userLlmUsageApiSlice.middleware,
 ];
 
 const initializeDataLayer = (dmUrl, lmsUrl, legacyLmsUrl, storageService, httpErrorHandler = {}, studioUrl, refreshAuthToken) => {
@@ -48751,6 +49147,12 @@ exports.USER_CHAT_HISTORY_ENDPOINTS = USER_CHAT_HISTORY_ENDPOINTS;
 exports.USER_CHAT_HISTORY_QUERY_KEYS = USER_CHAT_HISTORY_QUERY_KEYS;
 exports.USER_CHAT_HISTORY_REDUCER_PATH = USER_CHAT_HISTORY_REDUCER_PATH;
 exports.USER_CHAT_HISTORY_REPORT_ACTIVE_STATES = USER_CHAT_HISTORY_REPORT_ACTIVE_STATES;
+exports.USER_LLM_RECENT_ACTIVITY_PAGE_SIZE = USER_LLM_RECENT_ACTIVITY_PAGE_SIZE;
+exports.USER_LLM_USAGE_ENDPOINTS = USER_LLM_USAGE_ENDPOINTS;
+exports.USER_LLM_USAGE_ERROR_MESSAGES = USER_LLM_USAGE_ERROR_MESSAGES;
+exports.USER_LLM_USAGE_MAX_LIMIT = USER_LLM_USAGE_MAX_LIMIT;
+exports.USER_LLM_USAGE_QUERY_KEYS = USER_LLM_USAGE_QUERY_KEYS;
+exports.USER_LLM_USAGE_REDUCER_PATH = USER_LLM_USAGE_REDUCER_PATH;
 exports.USER_PROGRESS_DATA_POINTS = USER_PROGRESS_DATA_POINTS;
 exports.USER_PROGRESS_SUMMARY_TYPE = USER_PROGRESS_SUMMARY_TYPE;
 exports.WATCHED_GROUPS_ENDPOINTS = WATCHED_GROUPS_ENDPOINTS;
@@ -48804,6 +49206,7 @@ exports.evalTotalPages = evalTotalPages;
 exports.evaluationsApiSlice = evaluationsApiSlice;
 exports.fakeBaseQueryWithLogging = fakeBaseQueryWithLogging;
 exports.featureTags = featureTags;
+exports.fetchUserLlmUsage = fetchUserLlmUsage;
 exports.filterCourseUserRoles = filterCourseUserRoles;
 exports.filterGlobalUserRoles = filterGlobalUserRoles;
 exports.filterOrgUserRoles = filterOrgUserRoles;
@@ -48818,6 +49221,7 @@ exports.isBaseAgentMentor = isBaseAgentMentor;
 exports.isPoliciesResponse = isPoliciesResponse;
 exports.isPrivacyBlockedError = isPrivacyBlockedError;
 exports.isSpendCapExceededErrorBody = isSpendCapExceededErrorBody;
+exports.isUserLlmUsageEmpty = isUserLlmUsageEmpty;
 exports.llmsApiSlice = llmsApiSlice;
 exports.mcpApiSlice = mcpApiSlice;
 exports.memoryApiSlice = memoryApiSlice;
@@ -48830,6 +49234,7 @@ exports.mentorReducer = mentorReducer;
 exports.moderationLogsApiReducer = moderationLogsApiReducer;
 exports.moderationLogsApiSlice = moderationLogsApiSlice;
 exports.monetizationApiSlice = monetizationApiSlice;
+exports.normalizeUserLlmUsageError = normalizeUserLlmUsageError;
 exports.notificationsApiSlice = notificationsApiSlice;
 exports.notificationsCustomApiSlice = notificationsCustomApiSlice;
 exports.perLearnerApiSlice = perLearnerApiSlice;
@@ -48839,6 +49244,7 @@ exports.platformApiSlice = platformApiSlice;
 exports.platformCustomApiSlice = platformCustomApiSlice;
 exports.projectsApiSlice = projectsApiSlice;
 exports.promptsApiSlice = promptsApiSlice;
+exports.readMeasure = readMeasure;
 exports.reportsApiSlice = reportsApiSlice;
 exports.resolveEffectiveAgentSkills = resolveEffectiveAgentSkills;
 exports.retirementApiSlice = retirementApiSlice;
@@ -48854,6 +49260,7 @@ exports.supportTicketsApiSlice = supportTicketsApiSlice;
 exports.tenantApiReducer = tenantApiReducer;
 exports.tenantApiSlice = tenantApiSlice;
 exports.tenantLogoApiSlice = tenantLogoApiSlice;
+exports.toUserLlmUsageEnvelope = toUserLlmUsageEnvelope;
 exports.toolsApiSlice = toolsApiSlice;
 exports.trainingDocumentsApiSlice = trainingDocumentsApiSlice;
 exports.unwrapApiTokenList = unwrapApiTokenList;
@@ -49271,6 +49678,9 @@ exports.useGetUserEnrolledProgramsQuery = useGetUserEnrolledProgramsQuery;
 exports.useGetUserExperienceQuery = useGetUserExperienceQuery;
 exports.useGetUserInstitutionsQuery = useGetUserInstitutionsQuery;
 exports.useGetUserInvitationsQuery = useGetUserInvitationsQuery;
+exports.useGetUserLlmUsageMetricsQuery = useGetUserLlmUsageMetricsQuery;
+exports.useGetUserLlmUsageObservationsQuery = useGetUserLlmUsageObservationsQuery;
+exports.useGetUserLlmUsageTracesQuery = useGetUserLlmUsageTracesQuery;
 exports.useGetUserMemorySettingsQuery = useGetUserMemorySettingsQuery;
 exports.useGetUserMetadataEdxQuery = useGetUserMetadataEdxQuery;
 exports.useGetUserMetadataQuery = useGetUserMetadataQuery;
@@ -49682,12 +50092,23 @@ exports.useUploadStudioScormPackageMutation = useUploadStudioScormPackageMutatio
 exports.useUpsertAgentSpendCapMutation = useUpsertAgentSpendCapMutation;
 exports.useUpsertTenantSpendCapMutation = useUpsertTenantSpendCapMutation;
 exports.useUpsertUserSpendCapMutation = useUpsertUserSpendCapMutation;
+exports.useUserLlmCostByModel = useUserLlmCostByModel;
+exports.useUserLlmCostByService = useUserLlmCostByService;
+exports.useUserLlmRecentActivity = useUserLlmRecentActivity;
+exports.useUserLlmSpendOverTime = useUserLlmSpendOverTime;
+exports.useUserLlmTraceObservations = useUserLlmTraceObservations;
+exports.useUserLlmUsageMetrics = useUserLlmUsageMetrics;
+exports.useUserLlmUsageObservations = useUserLlmUsageObservations;
+exports.useUserLlmUsageSummary = useUserLlmUsageSummary;
+exports.useUserLlmUsageTraces = useUserLlmUsageTraces;
 exports.useUsersGradesPassedQuery = useUsersGradesPassedQuery;
 exports.useValidateWorkflowMutation = useValidateWorkflowMutation;
 exports.useWithdrawApplicationMutation = useWithdrawApplicationMutation;
 exports.userApiSlice = userApiSlice;
 exports.userChatHistoryApiSlice = userChatHistoryApiSlice;
 exports.userInvitationsApiSlice = userInvitationsApiSlice;
+exports.userLlmUsageApiSlice = userLlmUsageApiSlice;
+exports.validateUserLlmUsageParams = validateUserLlmUsageParams;
 exports.watchedGroupsApiSlice = watchedGroupsApiSlice;
 exports.workflowsApiSlice = workflowsApiSlice;
 //# sourceMappingURL=index.js.map