@beeuni/sdk 0.1.0

package/dist/react/use-project-apps.js

@@ -0,0 +1,185 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { createAppVolumeSnapshot, destroyAppMachine, destroyAppVolume, forkAppVolume, listAppMachines, listAppVolumeSnapshots, listAppVolumes, restartAppMachine, restoreAppVolume, scaleApp, startAppMachine, stopAppMachine, updateAppVolume, createApp, createAppAccessSession, createAppDeployment, deleteApp, getAppAccess, getAppDeployment, listAppDeployments, listApps, rollbackApp, startApp, stopApp, updateApp, updateAppAccess, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export const projectAppsKey = (projectId) => qk.project.apps(projectId ?? '');
+export const appDeploymentsKey = (projectId, appId) => qk.project.appDeployments(projectId ?? '', appId ?? '');
+export const appDeploymentKey = (projectId, appId, deploymentId) => qk.project.appDeployment(projectId ?? '', appId ?? '', deploymentId ?? '');
+const SETTLED_DEPLOYMENT = new Set(['ready', 'failed', 'cancelled']);
+export function useProjectApps(projectId) {
+    const queryClient = useQueryClient();
+    const queryKey = projectAppsKey(projectId);
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listApps(projectId),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey });
+    const create = useMutation({
+        mutationFn: (input) => createApp(projectId, input),
+        onSuccess: invalidate,
+    });
+    const update = useMutation({
+        mutationFn: (args) => updateApp(projectId, args.appId, args.input),
+        onSuccess: invalidate,
+    });
+    const start = useMutation({
+        mutationFn: (appId) => startApp(projectId, appId),
+        onSuccess: invalidate,
+    });
+    const stop = useMutation({
+        mutationFn: (appId) => stopApp(projectId, appId),
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: (appId) => deleteApp(projectId, appId),
+        onSuccess: invalidate,
+    });
+    return { ...query, create, update, start, stop, remove };
+}
+export function useAppDeployments(projectId, appId) {
+    const queryClient = useQueryClient();
+    const queryKey = appDeploymentsKey(projectId, appId);
+    const appsKey = projectAppsKey(projectId);
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listAppDeployments(projectId, appId),
+        enabled: !!projectId && !!appId,
+        ...contract('inventory'),
+        refetchInterval: 5_000,
+    });
+    const invalidate = () => {
+        void queryClient.invalidateQueries({ queryKey: appsKey });
+        void queryClient.invalidateQueries({ queryKey });
+    };
+    const deploy = useMutation({
+        mutationFn: (input) => createAppDeployment(projectId, appId, input),
+        onSuccess: invalidate,
+    });
+    const rollback = useMutation({
+        mutationFn: (deploymentId) => rollbackApp(projectId, appId, deploymentId),
+        onSuccess: invalidate,
+    });
+    return { ...query, deploy, rollback };
+}
+export function useAppDeployment(projectId, appId, deploymentId) {
+    return useQuery({
+        queryKey: appDeploymentKey(projectId, appId, deploymentId),
+        queryFn: () => getAppDeployment(projectId, appId, deploymentId),
+        enabled: !!projectId && !!appId && !!deploymentId,
+        ...contract('inventory'),
+        refetchInterval: (query) => query.state.data && SETTLED_DEPLOYMENT.has(query.state.data.deployment.status) ? false : 2_000,
+    });
+}
+export function useAppAccess(projectId, appId, options = {}) {
+    const queryClient = useQueryClient();
+    const wantsPolicy = options.policy ?? true;
+    const wantsSession = options.session ?? true;
+    const queryKey = qk.project.appAccess(projectId ?? '', appId ?? '');
+    const sessionQueryKey = qk.project.appAccessSession(projectId ?? '', appId ?? '');
+    const policy = useQuery({
+        queryKey,
+        queryFn: () => getAppAccess(projectId, appId),
+        enabled: !!projectId && !!appId && wantsPolicy,
+        ...contract('config'),
+    });
+    const session = useQuery({
+        queryKey: sessionQueryKey,
+        queryFn: () => createAppAccessSession(projectId, appId),
+        enabled: !!projectId && !!appId && wantsSession,
+        staleTime: 4 * 60_000,
+        gcTime: 5 * 60_000,
+        retry: false,
+    });
+    const update = useMutation({
+        mutationFn: (input) => updateAppAccess(projectId, appId, input),
+        onSuccess: async () => {
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey }),
+                queryClient.invalidateQueries({ queryKey: sessionQueryKey }),
+                queryClient.invalidateQueries({ queryKey: qk.project.apps(projectId ?? '') }),
+            ]);
+        },
+    });
+    return { policy, session, update };
+}
+export const appMachinesKey = (projectId, appId) => qk.project.appMachines(projectId ?? '', appId ?? '');
+export const appVolumesKey = (projectId, appId) => qk.project.appVolumes(projectId ?? '', appId ?? '');
+export function useAppMachines(projectId, appId) {
+    const queryClient = useQueryClient();
+    const queryKey = appMachinesKey(projectId, appId);
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listAppMachines(projectId, appId),
+        enabled: !!projectId && !!appId,
+        ...contract('inventory'),
+        refetchInterval: 5_000,
+    });
+    const invalidate = () => Promise.all([
+        queryClient.invalidateQueries({ queryKey }),
+        queryClient.invalidateQueries({ queryKey: projectAppsKey(projectId) }),
+    ]);
+    const start = useMutation({
+        mutationFn: (machineId) => startAppMachine(projectId, appId, machineId),
+        onSuccess: invalidate,
+    });
+    const stop = useMutation({
+        mutationFn: (machineId) => stopAppMachine(projectId, appId, machineId),
+        onSuccess: invalidate,
+    });
+    const restart = useMutation({
+        mutationFn: (machineId) => restartAppMachine(projectId, appId, machineId),
+        onSuccess: invalidate,
+    });
+    const destroy = useMutation({
+        mutationFn: (machineId) => destroyAppMachine(projectId, appId, machineId),
+        onSuccess: invalidate,
+    });
+    const scale = useMutation({
+        mutationFn: (count) => scaleApp(projectId, appId, count),
+        onSuccess: invalidate,
+    });
+    return { ...query, start, stop, restart, destroy, scale };
+}
+export function useAppVolumes(projectId, appId) {
+    const queryClient = useQueryClient();
+    const queryKey = appVolumesKey(projectId, appId);
+    const query = useQuery({
+        queryKey,
+        queryFn: () => listAppVolumes(projectId, appId),
+        enabled: !!projectId && !!appId,
+        ...contract('inventory'),
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey });
+    const snapshot = useMutation({
+        mutationFn: (volumeId) => createAppVolumeSnapshot(projectId, appId, volumeId),
+        onSuccess: invalidate,
+    });
+    const restore = useMutation({
+        mutationFn: (input) => restoreAppVolume(projectId, appId, input.volumeId, input.snapshotId),
+        onSuccess: invalidate,
+    });
+    const fork = useMutation({
+        mutationFn: (input) => forkAppVolume(projectId, appId, input.volumeId, { name: input.name, snapshot_id: input.snapshotId }),
+        onSuccess: invalidate,
+    });
+    const extend = useMutation({
+        mutationFn: (input) => updateAppVolume(projectId, appId, input.volumeId, { size_gb: input.sizeGb }),
+        onSuccess: invalidate,
+    });
+    const destroy = useMutation({
+        mutationFn: (input) => destroyAppVolume(projectId, appId, input.volumeId, input.name),
+        onSuccess: invalidate,
+    });
+    return { ...query, snapshot, restore, fork, extend, destroy };
+}
+export function useAppVolumeSnapshots(projectId, appId, volumeId) {
+    return useQuery({
+        queryKey: qk.project.appVolumeSnapshots(projectId ?? '', appId ?? '', volumeId ?? ''),
+        queryFn: () => listAppVolumeSnapshots(projectId, appId, volumeId),
+        enabled: !!projectId && !!appId && !!volumeId,
+        ...contract('inventory'),
+    });
+}

package/dist/react/use-project-config.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectConfigSummary } from '../core/rest/projects-client/index.js';
+export declare function useProjectConfig(projectId: string | null | undefined): ProjectConfigSummary | undefined;

package/dist/react/use-project-config.js

@@ -0,0 +1,16 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getProjectDetail, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useProjectConfig(projectId) {
+    const { data } = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        select: (detail) => detail.config,
+        enabled: !!projectId,
+        ...contract('config'),
+        retry: false,
+    });
+    return data;
+}

package/dist/react/use-project-files.d.ts

@@ -0,0 +1,87 @@
+import { type Drive, type DriveConflict, type DriveEntry, type FolderAccess, type FolderAccessView, type FolderLevel, type FolderPrincipalType, type FolderPrincipals, type SessionDrives } from '../core/rest/projects-client/drives.js';
+export declare function projectDriveQueryOptions(projectId: string | undefined, userId: string | null | undefined, enabled?: boolean): {
+    queryKey: readonly ["kx", "drives", "list", string, string];
+    queryFn: () => Promise<Drive>;
+    enabled: boolean;
+    staleTime: number;
+};
+export declare function driveFolderQueryOptions(driveId: string | null, path: string): {
+    queryKey: readonly ["kx", "drives", "drive", string, "files", string];
+    queryFn: () => Promise<{
+        entries: DriveEntry[];
+        access: FolderAccess;
+    }>;
+    enabled: boolean;
+    refetchInterval: (query: {
+        state: {
+            status: string;
+        };
+    }) => number | false;
+    staleTime: number;
+};
+export declare function folderAccessQueryOptions(driveId: string | null, path: string, enabled?: boolean): {
+    queryKey: readonly ["kx", "drives", "drive", string, "grants", string];
+    queryFn: () => Promise<FolderAccessView>;
+    enabled: boolean;
+};
+export declare function folderPrincipalsQueryOptions(driveId: string | null, enabled?: boolean): {
+    queryKey: readonly ["kx", "drives", "drive", string, "principals"];
+    queryFn: () => Promise<FolderPrincipals>;
+    enabled: boolean;
+    staleTime: number;
+};
+export declare function driveConflictsQueryOptions(driveId: string | null, enabled?: boolean): {
+    queryKey: readonly ["kx", "drives", "drive", string, "conflicts"];
+    queryFn: () => Promise<DriveConflict[]>;
+    enabled: boolean;
+    refetchInterval: false | ((query: {
+        state: {
+            status: string;
+        };
+    }) => number | false);
+};
+export declare function sessionDrivesQueryOptions(projectId: string | undefined, sessionId: string | undefined, filesEnabled: boolean): {
+    queryKey: readonly ["kx", "drives", "session", string, string];
+    queryFn: () => Promise<SessionDrives>;
+    enabled: boolean;
+    refetchInterval: (query: {
+        state: {
+            status: string;
+        };
+    }) => number | false;
+    staleTime: number;
+};
+export declare function useDriveAvailability(projectId: string | undefined): {
+    enabled: boolean;
+    isLoading: boolean;
+};
+export declare function useProjectDrive(projectId: string | undefined, userId: string | null | undefined, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<Drive, Error>;
+export declare function useDriveFolder(driveId: string | null, path: string): import("@tanstack/react-query").UseQueryResult<{
+    entries: DriveEntry[];
+    access: FolderAccess;
+}, Error>;
+export declare function useFolderAccess(driveId: string | null, path: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<FolderAccessView, Error>;
+export declare function useFolderPrincipals(driveId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<FolderPrincipals, Error>;
+export declare function useSessionDrives(projectId: string | undefined, sessionId: string | undefined): import("@tanstack/react-query").UseQueryResult<SessionDrives, Error>;
+export declare function useDriveConflicts(driveId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<DriveConflict[], Error>;
+export declare function useInvalidateDrives(): () => Promise<void>;
+export declare function useShareFolder(): import("@tanstack/react-query").UseMutationResult<{
+    grantId: string;
+    pendingSessions?: number;
+}, Error, {
+    driveId: string;
+    path: string;
+    principalType: FolderPrincipalType;
+    principalId?: string;
+    level: FolderLevel;
+}, unknown>;
+export declare function useUnshareFolder(): import("@tanstack/react-query").UseMutationResult<{
+    pendingSessions: number;
+}, Error, {
+    driveId: string;
+    grantId: string;
+}, unknown>;
+export declare function useDismissDriveConflict(): import("@tanstack/react-query").UseMutationResult<void, Error, {
+    driveId: string;
+    conflictId: string;
+}, unknown>;

package/dist/react/use-project-files.js

@@ -0,0 +1,109 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { dismissDriveConflict, getFolderAccess, getProjectDrive, getSessionDrives, listDriveConflicts, listDriveFolder, listFolderPrincipals, shareFolder, unshareFolder, } from '../core/rest/projects-client/drives.js';
+import { qk } from './query-keys.js';
+import { useFeatureFlag } from './use-feature-flag.js';
+const LIVE_POLL_MS = 10_000;
+const pollUnlessFailing = (interval) => (query) => query.state.status === 'error' ? false : interval;
+export function projectDriveQueryOptions(projectId, userId, enabled = true) {
+    return {
+        queryKey: qk.drives.list(userId, { projectId }),
+        queryFn: () => getProjectDrive(projectId),
+        enabled: enabled && !!projectId && !!userId,
+        staleTime: 15_000,
+    };
+}
+export function driveFolderQueryOptions(driveId, path) {
+    return {
+        queryKey: qk.drives.files(driveId ?? '', path),
+        queryFn: () => listDriveFolder(driveId, path),
+        enabled: !!driveId,
+        refetchInterval: pollUnlessFailing(LIVE_POLL_MS),
+        staleTime: 2_000,
+    };
+}
+export function folderAccessQueryOptions(driveId, path, enabled = true) {
+    return {
+        queryKey: [...qk.drives.grants(driveId ?? ''), path],
+        queryFn: () => getFolderAccess(driveId, path),
+        enabled: !!driveId && enabled,
+    };
+}
+export function folderPrincipalsQueryOptions(driveId, enabled = true) {
+    return {
+        queryKey: [...qk.drives.drive(driveId ?? ''), 'principals'],
+        queryFn: () => listFolderPrincipals(driveId),
+        enabled: !!driveId && enabled,
+        staleTime: 60_000,
+    };
+}
+export function driveConflictsQueryOptions(driveId, enabled = true) {
+    return {
+        queryKey: qk.drives.conflicts(driveId ?? ''),
+        queryFn: () => listDriveConflicts(driveId),
+        enabled: !!driveId && enabled,
+        refetchInterval: enabled ? pollUnlessFailing(LIVE_POLL_MS * 2) : false,
+    };
+}
+export function sessionDrivesQueryOptions(projectId, sessionId, filesEnabled) {
+    return {
+        queryKey: qk.drives.session(projectId ?? '', sessionId ?? ''),
+        queryFn: () => getSessionDrives(projectId, sessionId),
+        enabled: filesEnabled && !!projectId && !!sessionId,
+        refetchInterval: pollUnlessFailing(LIVE_POLL_MS * 2),
+        staleTime: 10_000,
+    };
+}
+export function useDriveAvailability(projectId) {
+    const flag = useFeatureFlag(projectId, 'drives');
+    return { enabled: flag.enabled, isLoading: flag.isLoading };
+}
+export function useProjectDrive(projectId, userId, enabled = true) {
+    return useQuery(projectDriveQueryOptions(projectId, userId, enabled));
+}
+export function useDriveFolder(driveId, path) {
+    return useQuery(driveFolderQueryOptions(driveId, path));
+}
+export function useFolderAccess(driveId, path, enabled = true) {
+    return useQuery(folderAccessQueryOptions(driveId, path, enabled));
+}
+export function useFolderPrincipals(driveId, enabled = true) {
+    return useQuery(folderPrincipalsQueryOptions(driveId, enabled));
+}
+export function useSessionDrives(projectId, sessionId) {
+    const flag = useFeatureFlag(projectId, 'drives');
+    return useQuery(sessionDrivesQueryOptions(projectId, sessionId, flag.enabled));
+}
+export function useDriveConflicts(driveId, enabled = true) {
+    return useQuery(driveConflictsQueryOptions(driveId, enabled));
+}
+export function useInvalidateDrives() {
+    const queryClient = useQueryClient();
+    return () => queryClient.invalidateQueries({ queryKey: qk.drives.scope() });
+}
+export function useShareFolder() {
+    const invalidate = useInvalidateDrives();
+    return useMutation({
+        mutationFn: (input) => shareFolder(input.driveId, input),
+        onSettled: invalidate,
+        retry: false,
+        onError: () => undefined,
+    });
+}
+export function useUnshareFolder() {
+    const invalidate = useInvalidateDrives();
+    return useMutation({
+        mutationFn: (input) => unshareFolder(input.driveId, input.grantId),
+        onSettled: invalidate,
+        retry: false,
+        onError: () => undefined,
+    });
+}
+export function useDismissDriveConflict() {
+    const invalidate = useInvalidateDrives();
+    return useMutation({
+        mutationFn: async (input) => {
+            await dismissDriveConflict(input.driveId, input.conflictId);
+        },
+        onSettled: invalidate,
+    });
+}

package/dist/react/use-project-gateway.d.ts

@@ -0,0 +1,26 @@
+import { type SetGatewayBudgetInput } from '../core/rest/projects-client/gateway.js';
+export declare function useGatewayOverview(projectId: string | undefined, days?: number): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayOverview, Error>;
+export declare function useGatewaySeries(projectId: string | undefined, days?: number): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewaySeries, Error>;
+export declare function useGatewayBreakdown(projectId: string | undefined, days?: number): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayBreakdown, Error>;
+export declare function useGatewaySessions(projectId: string | undefined, days?: number): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewaySessions, Error>;
+export declare function useGatewayErrors(projectId: string | undefined, days?: number): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayErrorsResponse, Error>;
+export declare const GATEWAY_LOGS_PAGE_SIZE = 100;
+export declare function useGatewayLogs(projectId: string | undefined, opts?: {
+    ok?: boolean;
+}): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<import("../index.js").GatewayLogsResponse, unknown>, Error>;
+export declare function useGatewayLog(projectId: string | undefined, logId: string | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayLogDetail, Error>;
+export declare function useGatewayBudgets(projectId: string | undefined): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayBudgetsResponse, Error>;
+export declare function useSetGatewayBudget(projectId: string | undefined): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+}, Error, SetGatewayBudgetInput, unknown>;
+export declare function useDeleteGatewayBudget(projectId: string | undefined): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+}, Error, string, unknown>;
+export declare function useGatewayKeys(projectId: string | undefined, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<{
+    keys: import("../index.js").GatewayKeyRow[];
+    gateway_url?: string | null;
+}, Error>;
+export declare function useCreateGatewayKey(projectId: string | undefined): import("@tanstack/react-query").UseMutationResult<import("../index.js").CreatedGatewayKey, Error, string, unknown>;
+export declare function useRevokeGatewayKey(projectId: string | undefined): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+}, Error, string, unknown>;

package/dist/react/use-project-gateway.js

@@ -0,0 +1,111 @@
+'use client';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { createGatewayKey, deleteGatewayBudget, getGatewayBreakdown, getGatewayBudgets, getGatewayErrors, getGatewayKeys, getGatewayLog, getGatewayOverview, getGatewaySeries, getGatewaySessions, listGatewayLogs, revokeGatewayKey, setGatewayBudget, } from '../core/rest/projects-client/gateway.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useGatewayOverview(projectId, days = 30) {
+    return useQuery({
+        queryKey: qk.project.gatewayOverview(projectId ?? '', days),
+        queryFn: () => getGatewayOverview(projectId, days),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export function useGatewaySeries(projectId, days = 30) {
+    return useQuery({
+        queryKey: qk.project.gatewaySeries(projectId ?? '', days),
+        queryFn: () => getGatewaySeries(projectId, days),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export function useGatewayBreakdown(projectId, days = 30) {
+    return useQuery({
+        queryKey: qk.project.gatewayBreakdown(projectId ?? '', days),
+        queryFn: () => getGatewayBreakdown(projectId, days),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export function useGatewaySessions(projectId, days = 30) {
+    return useQuery({
+        queryKey: qk.project.gatewaySessions(projectId ?? '', days),
+        queryFn: () => getGatewaySessions(projectId, days),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export function useGatewayErrors(projectId, days = 30) {
+    return useQuery({
+        queryKey: qk.project.gatewayErrors(projectId ?? '', days),
+        queryFn: () => getGatewayErrors(projectId, days),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export const GATEWAY_LOGS_PAGE_SIZE = 100;
+export function useGatewayLogs(projectId, opts) {
+    return useInfiniteQuery({
+        queryKey: qk.project.gatewayLogs(projectId ?? '', opts?.ok ?? null),
+        queryFn: ({ pageParam }) => listGatewayLogs(projectId, {
+            ok: opts?.ok,
+            limit: GATEWAY_LOGS_PAGE_SIZE,
+            offset: pageParam,
+        }),
+        initialPageParam: 0,
+        getNextPageParam: (last) => last.next_offset ?? undefined,
+        enabled: !!projectId,
+        refetchInterval: (query) => ((query.state.data?.pages.length ?? 1) > 1 ? false : 10_000),
+    });
+}
+export function useGatewayLog(projectId, logId) {
+    return useQuery({
+        queryKey: qk.project.gatewayLog(projectId ?? '', logId),
+        queryFn: () => getGatewayLog(projectId, logId),
+        enabled: !!projectId && !!logId,
+    });
+}
+export function useGatewayBudgets(projectId) {
+    return useQuery({
+        queryKey: qk.project.gatewayBudgets(projectId ?? ''),
+        queryFn: () => getGatewayBudgets(projectId),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+}
+export function useSetGatewayBudget(projectId) {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => setGatewayBudget(projectId, input),
+        onSuccess: () => qc.invalidateQueries({ queryKey: qk.project.gatewayBudgets(projectId ?? '') }),
+    });
+}
+export function useDeleteGatewayBudget(projectId) {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (budgetId) => deleteGatewayBudget(projectId, budgetId),
+        onSuccess: () => qc.invalidateQueries({ queryKey: qk.project.gatewayBudgets(projectId ?? '') }),
+    });
+}
+export function useGatewayKeys(projectId, enabled = true) {
+    return useQuery({
+        queryKey: qk.project.gatewayKeys(projectId ?? ''),
+        queryFn: () => getGatewayKeys(projectId),
+        enabled: !!projectId && enabled,
+        ...contract('inventory'),
+    });
+}
+export function useCreateGatewayKey(projectId) {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (name) => createGatewayKey(projectId, name),
+        onSuccess: () => qc.invalidateQueries({ queryKey: qk.project.gatewayKeys(projectId ?? '') }),
+    });
+}
+export function useRevokeGatewayKey(projectId) {
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: (keyId) => revokeGatewayKey(projectId, keyId),
+        onSuccess: () => qc.invalidateQueries({ queryKey: qk.project.gatewayKeys(projectId ?? '') }),
+    });
+}

package/dist/react/use-project-llm-gateway.d.ts

@@ -0,0 +1,6 @@
+import { type ProjectDetail } from '../core/rest/projects-client/index.js';
+export declare function projectDetailLlmGatewayEnabled(detail: ProjectDetail | undefined): boolean;
+export declare function useProjectLlmGatewayEnabled(projectId: string | null | undefined): {
+    enabled: boolean;
+    known: boolean;
+};

package/dist/react/use-project-llm-gateway.js

@@ -0,0 +1,20 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getProjectDetail } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function projectDetailLlmGatewayEnabled(detail) {
+    return detail?.project?.experimental?.llm_gateway === true;
+}
+export function useProjectLlmGatewayEnabled(projectId) {
+    const detailQuery = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: !!projectId,
+        ...contract('config'),
+    });
+    return {
+        enabled: !!projectId && projectDetailLlmGatewayEnabled(detailQuery.data),
+        known: !projectId || detailQuery.isSuccess,
+    };
+}

package/dist/react/use-project-models.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectLlmCatalogResponse } from '../core/rest/projects-client/index.js';
+import { type FlatModel } from './model-flatten.js';
+export declare function useProjectModelPickerCatalog(projectId: string | null | undefined): ProjectLlmCatalogResponse | undefined;
+export declare function useProjectModels(projectId: string | null | undefined): FlatModel[];

package/dist/react/use-project-models.js

@@ -0,0 +1,31 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { getProjectModelPicker } from '../core/rest/projects-client/index.js';
+import { flattenModels } from './model-flatten.js';
+import { projectLlmCatalogToProviderList } from './provider-selection.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+import { useProjectLlmGatewayEnabled } from './use-project-llm-gateway.js';
+export function useProjectModelPickerCatalog(projectId) {
+    const gateway = useProjectLlmGatewayEnabled(projectId);
+    const { data } = useQuery({
+        queryKey: qk.project.modelPicker(projectId ?? ''),
+        queryFn: () => getProjectModelPicker(projectId),
+        enabled: !!projectId && gateway.enabled,
+        ...contract('config'),
+        retry: false,
+    });
+    return data;
+}
+export function useProjectModels(projectId) {
+    const gateway = useProjectLlmGatewayEnabled(projectId);
+    const { data } = useQuery({
+        queryKey: qk.project.modelPicker(projectId ?? ''),
+        queryFn: () => getProjectModelPicker(projectId),
+        enabled: !!projectId && gateway.enabled,
+        ...contract('config'),
+        retry: false,
+    });
+    return useMemo(() => (data ? flattenModels(projectLlmCatalogToProviderList(data)) : []), [data]);
+}

package/dist/react/use-project-name.d.ts

@@ -0,0 +1,4 @@
+import type { BeeuniProject } from '../core/rest/projects-client/index.js';
+export declare function useProjectName(projectId: string | undefined): string | undefined;
+export declare function useProjectAccountId(projectId: string | undefined): string | undefined;
+export declare function useProjectIcon(projectId: string | undefined): Pick<BeeuniProject, 'icon' | 'icon_glyph'> | undefined;

package/dist/react/use-project-name.js

@@ -0,0 +1,35 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getProjectDetail } from '../core/rest/projects-client/index.js';
+import { qk } from './query-keys.js';
+import { contract } from './query-contracts.js';
+export function useProjectName(projectId) {
+    const { data } = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: Boolean(projectId),
+        ...contract('config'),
+    });
+    return data?.project?.name;
+}
+export function useProjectAccountId(projectId) {
+    const { data } = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: Boolean(projectId),
+        ...contract('config'),
+    });
+    return data?.project?.account_id;
+}
+export function useProjectIcon(projectId) {
+    const { data } = useQuery({
+        queryKey: qk.project.detail(projectId ?? ''),
+        queryFn: () => getProjectDetail(projectId),
+        enabled: Boolean(projectId),
+        ...contract('config'),
+    });
+    const project = data?.project;
+    if (!project)
+        return undefined;
+    return { icon: project.icon ?? null, icon_glyph: project.icon_glyph ?? null };
+}