@beeuni/sdk 0.1.0

package/dist/react/use-gateway-routing-policy.d.ts

@@ -0,0 +1,8 @@
+import { type GatewayProjectRoutingPolicy, type GatewayRoutePreviewInput } from "../core/rest/projects-client/index.js";
+export declare const gatewayRoutingPolicyKey: (projectId: string | null | undefined) => readonly ["gateway-routing-policy", string | null | undefined];
+export declare function useGatewayRoutingPolicy(projectId: string | null | undefined): import("@tanstack/react-query").UseQueryResult<import("../index.js").GatewayRoutingPolicyDocument, Error> & {
+    llmGatewayEnabled: boolean;
+    set: import("@tanstack/react-query").UseMutationResult<import("../index.js").GatewayRoutingPolicyDocument, Error, GatewayProjectRoutingPolicy, unknown>;
+    reset: import("@tanstack/react-query").UseMutationResult<import("../index.js").GatewayRoutingPolicyDocument, Error, void, unknown>;
+    preview: import("@tanstack/react-query").UseMutationResult<import("../index.js").GatewayRoutePreview, Error, GatewayRoutePreviewInput, unknown>;
+};

package/dist/react/use-gateway-routing-policy.js

@@ -0,0 +1,36 @@
+"use client";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { getGatewayRoutingPolicy, previewGatewayRoute, resetGatewayRoutingPolicy, setGatewayRoutingPolicy, } from "../core/rest/projects-client/index.js";
+import { qk } from "./query-keys.js";
+import { useProjectLlmGatewayEnabled } from "./use-project-llm-gateway.js";
+export const gatewayRoutingPolicyKey = (projectId) => ["gateway-routing-policy", projectId];
+export function useGatewayRoutingPolicy(projectId) {
+    const queryClient = useQueryClient();
+    const gateway = useProjectLlmGatewayEnabled(projectId);
+    const query = useQuery({
+        queryKey: gatewayRoutingPolicyKey(projectId),
+        queryFn: () => getGatewayRoutingPolicy(projectId),
+        enabled: !!projectId && gateway.enabled,
+        retry: false,
+    });
+    const invalidate = () => Promise.all([
+        queryClient.invalidateQueries({ queryKey: gatewayRoutingPolicyKey(projectId) }),
+        queryClient.invalidateQueries({ queryKey: qk.project.modelAccess(projectId ?? '') }),
+    ]);
+    return Object.assign(query, {
+        llmGatewayEnabled: !!projectId && gateway.enabled,
+        set: useMutation({
+            mutationKey: gatewayRoutingPolicyKey(projectId),
+            mutationFn: (policy) => setGatewayRoutingPolicy(projectId, policy),
+            onSuccess: invalidate,
+        }),
+        reset: useMutation({
+            mutationKey: gatewayRoutingPolicyKey(projectId),
+            mutationFn: () => resetGatewayRoutingPolicy(projectId),
+            onSuccess: invalidate,
+        }),
+        preview: useMutation({
+            mutationFn: (input) => previewGatewayRoute(projectId, input),
+        }),
+    });
+}

package/dist/react/use-impersonation.d.ts

@@ -0,0 +1,20 @@
+import { type ImpersonationSession } from '../core/http/impersonation.js';
+export declare const ADMIN_IMPERSONATE_PATH = "/admin/api/impersonate";
+export declare function adminImpersonateRevokePath(grantId: string): string;
+export declare const ADMIN_IMPERSONATE_ACTIVE_PATH = "/admin/api/impersonate/active";
+export interface AdminImpersonateResponse {
+    grant_id: string;
+    account_id: string;
+    account_name?: string | null;
+    expires_at: string;
+}
+export declare function useImpersonation(): ImpersonationSession | null;
+export declare function useAdminImpersonate(): import("@tanstack/react-query").UseMutationResult<AdminImpersonateResponse, Error, {
+    accountId: string;
+    reason?: string;
+}, unknown>;
+export declare function useStopImpersonation(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+} | null, Error, void | {
+    grantId?: string;
+}, unknown>;

package/dist/react/use-impersonation.js

@@ -0,0 +1,55 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useSyncExternalStore } from 'react';
+import { backendApi } from '../core/http/api-client.js';
+import { clearImpersonationSession, getImpersonationSession, setImpersonationSession, subscribeToImpersonation, } from '../core/http/impersonation.js';
+export const ADMIN_IMPERSONATE_PATH = '/admin/api/impersonate';
+export function adminImpersonateRevokePath(grantId) {
+    return `${ADMIN_IMPERSONATE_PATH}/${encodeURIComponent(grantId)}`;
+}
+export const ADMIN_IMPERSONATE_ACTIVE_PATH = `${ADMIN_IMPERSONATE_PATH}/active`;
+export function useImpersonation() {
+    return useSyncExternalStore(subscribeToImpersonation, getImpersonationSession, () => null);
+}
+export function useAdminImpersonate() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, reason }) => {
+            const body = { account_id: accountId };
+            if (reason)
+                body.reason = reason;
+            const response = await backendApi.post(ADMIN_IMPERSONATE_PATH, body);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (data) => {
+            setImpersonationSession({
+                grantId: data.grant_id,
+                accountId: data.account_id,
+                accountName: data.account_name ?? null,
+                expiresAt: data.expires_at,
+            });
+            queryClient.clear();
+        },
+    });
+}
+export function useStopImpersonation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (variables) => {
+            const grantId = variables?.grantId ?? getImpersonationSession()?.grantId;
+            if (!grantId)
+                return null;
+            try {
+                const response = await backendApi.delete(adminImpersonateRevokePath(grantId));
+                if (response.error)
+                    throw new Error(response.error.message);
+                return response.data ?? { ok: true };
+            }
+            finally {
+                clearImpersonationSession();
+                queryClient.clear();
+            }
+        },
+    });
+}

package/dist/react/use-model-access.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectModelAccessChange } from "../core/rest/projects-client/model-access.js";
+export declare function useModelAccess(projectId: string | null | undefined): {
+    defaultProvider: string | undefined;
+    data: import("../index.js").ProjectModelAccess | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    isUpdating: boolean;
+    setEnabled: import("@tanstack/react-query").UseMutateAsyncFunction<import("../index.js").ProjectModelAccess, Error, ProjectModelAccessChange, unknown>;
+};

package/dist/react/use-model-access.js

@@ -0,0 +1,46 @@
+"use client";
+import { useIsMutating, useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { getProjectModelAccess, setProjectModelAccess, } from "../core/rest/projects-client/model-access.js";
+import { contract } from "./query-contracts.js";
+import { qk } from "./query-keys.js";
+export function useModelAccess(projectId) {
+    const queryClient = useQueryClient();
+    const queryKey = qk.project.modelAccess(projectId ?? "");
+    const query = useQuery({
+        queryKey,
+        queryFn: () => getProjectModelAccess(projectId),
+        enabled: !!projectId,
+        ...contract("config"),
+    });
+    const pending = useIsMutating({ mutationKey: queryKey });
+    const mutation = useMutation({
+        mutationKey: queryKey,
+        scope: { id: `project-model-access:${projectId}` },
+        mutationFn: (change) => setProjectModelAccess(projectId, change),
+        onSuccess: async (policy) => {
+            queryClient.setQueryData(queryKey, policy);
+            await queryClient.invalidateQueries({
+                queryKey: qk.project.modelPicker(projectId),
+                refetchType: "all",
+            });
+            await queryClient.invalidateQueries({
+                queryKey: ["project-providers", projectId],
+                refetchType: "all",
+            });
+        },
+    });
+    const defaultModel = query.data?.defaultModel?.replace(/^beeuni\//, "");
+    const defaultProvider = defaultModel
+        ? defaultModel.includes("/")
+            ? defaultModel.split("/")[0]
+            : "beeuni"
+        : undefined;
+    return {
+        defaultProvider,
+        data: query.data,
+        isLoading: query.isLoading,
+        error: query.error,
+        isUpdating: pending > 0,
+        setEnabled: mutation.mutateAsync,
+    };
+}

package/dist/react/use-model-defaults.d.ts

@@ -0,0 +1,23 @@
+import { type ModelDefaultsResponse } from '../core/rest/projects-client/model-defaults.js';
+import { type ModelKey } from './use-model-store.js';
+import { resolveModelDefault } from '../core/models/composer-model.js';
+export { resolveModelDefault };
+export interface UseModelDefaults {
+    data: ModelDefaultsResponse | undefined;
+    isLoading: boolean;
+    isUpdating: boolean;
+    llmGatewayEnabled: boolean;
+    accountDefault: ModelKey | undefined;
+    agentDefaults: Record<string, ModelKey>;
+    projectDefault: ModelKey | undefined;
+    platformDefault: ModelKey | undefined;
+    freeTier: boolean;
+    resolveDefaultFor: (agentName: string | undefined) => ModelKey | undefined;
+    setAccountDefault: (model: ModelKey) => Promise<void>;
+    setAgentDefault: (agentName: string, model: ModelKey) => Promise<void>;
+    setProjectDefault: (model: ModelKey) => Promise<void>;
+    clearAccountDefault: () => Promise<void>;
+    clearAgentDefault: (agentName: string) => Promise<void>;
+    clearProjectDefault: () => Promise<void>;
+}
+export declare function useModelDefaults(projectId: string | null | undefined): UseModelDefaults;

package/dist/react/use-model-defaults.js

@@ -0,0 +1,115 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useEffect, useMemo } from 'react';
+import { ApiError, MODEL_NOT_SERVABLE_CODE } from '../core/http/api-client.js';
+import { platformConfig } from '../core/http/config.js';
+import { clearModelDefault, getModelDefaults, setModelDefault, } from '../core/rest/projects-client/model-defaults.js';
+import { modelKeyToWire, seedGlobalDefaultFromServer, setGlobalDefaultModel, wireToModelKey, } from './use-model-store.js';
+import { resolveModelDefault } from '../core/models/composer-model.js';
+import { qk } from './query-keys.js';
+export { resolveModelDefault };
+import { useProjectLlmGatewayEnabled } from './use-project-llm-gateway.js';
+export function useModelDefaults(projectId) {
+    const queryClient = useQueryClient();
+    const queryKey = useMemo(() => ['model-defaults', projectId], [projectId]);
+    const gateway = useProjectLlmGatewayEnabled(projectId);
+    const { data, isLoading } = useQuery({
+        queryKey,
+        queryFn: () => getModelDefaults(projectId),
+        enabled: !!projectId && gateway.enabled,
+        staleTime: 30_000,
+    });
+    useEffect(() => {
+        if (!data)
+            return;
+        seedGlobalDefaultFromServer(data.accountDefault ? wireToModelKey(data.accountDefault) : undefined);
+    }, [data?.accountDefault]);
+    const invalidate = useCallback(async () => {
+        await Promise.all([
+            queryClient.invalidateQueries({ queryKey }),
+            queryClient.invalidateQueries({ queryKey: ['gateway-routing-policy', projectId] }),
+            queryClient.invalidateQueries({ queryKey: qk.project.modelPicker(projectId ?? '') }),
+            queryClient.invalidateQueries({ queryKey: qk.project.modelAccess(projectId ?? '') }),
+            queryClient.invalidateQueries({ queryKey: ['project-providers', projectId] }),
+        ]);
+    }, [projectId, queryClient, queryKey]);
+    const setMutation = useMutation({
+        mutationFn: (input) => setModelDefault(projectId, input),
+        onSuccess: invalidate,
+        onError: (error) => {
+            const message = error instanceof ApiError && error.code === MODEL_NOT_SERVABLE_CODE
+                ? error.message
+                : error instanceof Error
+                    ? error.message
+                    : 'Could not set the default model';
+            try {
+                platformConfig().onToast?.('error', message);
+            }
+            catch {
+            }
+        },
+    });
+    const clearMutation = useMutation({
+        mutationFn: (params) => clearModelDefault(projectId, params),
+        onSuccess: invalidate,
+    });
+    const accountDefault = useMemo(() => (data?.accountDefault ? wireToModelKey(data.accountDefault) : undefined), [data?.accountDefault]);
+    const agentDefaults = useMemo(() => {
+        const defaults = {};
+        for (const [name, wire] of Object.entries(data?.agentDefaults ?? {})) {
+            defaults[name] = wireToModelKey(wire);
+        }
+        return defaults;
+    }, [data?.agentDefaults]);
+    const projectDefault = useMemo(() => (data?.projectDefault ? wireToModelKey(data.projectDefault) : undefined), [data?.projectDefault]);
+    const platformDefault = useMemo(() => (data?.platformDefault ? wireToModelKey(data.platformDefault) : undefined), [data?.platformDefault]);
+    const resolveDefaultFor = useCallback((agentName) => resolveModelDefault(data, agentName), [data]);
+    const setAccountDefault = useCallback(async (model) => {
+        setGlobalDefaultModel(model);
+        await setMutation.mutateAsync({
+            scope: 'account',
+            model: modelKeyToWire(model),
+        });
+    }, [setMutation]);
+    const setAgentDefault = useCallback(async (agentName, model) => {
+        await setMutation.mutateAsync({
+            scope: 'agent',
+            agentName,
+            model: modelKeyToWire(model),
+        });
+    }, [setMutation]);
+    const setProjectDefault = useCallback(async (model) => {
+        await setMutation.mutateAsync({
+            scope: 'project',
+            model: modelKeyToWire(model),
+        });
+    }, [setMutation]);
+    const clearAccountDefault = useCallback(async () => {
+        setGlobalDefaultModel(undefined);
+        await clearMutation.mutateAsync({ scope: 'account' });
+    }, [clearMutation]);
+    const clearAgentDefault = useCallback(async (agentName) => {
+        await clearMutation.mutateAsync({ scope: 'agent', agentName });
+    }, [clearMutation]);
+    const clearProjectDefault = useCallback(async () => {
+        await clearMutation.mutateAsync({ scope: 'project' });
+    }, [clearMutation]);
+    return {
+        data,
+        isLoading,
+        isUpdating: setMutation.isPending || clearMutation.isPending,
+        llmGatewayEnabled: gateway.enabled,
+        accountDefault,
+        agentDefaults,
+        projectDefault,
+        platformDefault,
+        freeTier: data ? data.freeTier : true,
+        resolveDefaultFor,
+        setAccountDefault,
+        setAgentDefault,
+        setProjectDefault,
+        clearAccountDefault,
+        clearAgentDefault,
+        clearProjectDefault,
+    };
+}

package/dist/react/use-model-enablement.d.ts

@@ -0,0 +1,8 @@
+export interface UseModelEnablement {
+    usingDefaults: boolean;
+    defaultModel: string | undefined;
+    setEnabled: (wireModel: string, enabled: boolean) => Promise<void>;
+    resetToDefaults: () => Promise<void>;
+    isUpdating: boolean;
+}
+export declare function useModelEnablement(projectId: string | null | undefined): UseModelEnablement;

package/dist/react/use-model-enablement.js

@@ -0,0 +1,69 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { getProjectModelPicker } from '../core/rest/projects-client/index.js';
+import { setProjectModelEnablement } from '../core/rest/projects-client/model-enablement.js';
+import { applyEnablementToProviderList } 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 useModelEnablement(projectId) {
+    const queryClient = useQueryClient();
+    const queryKey = useMemo(() => qk.project.modelPicker(projectId ?? ''), [projectId]);
+    const providersKey = useMemo(() => ['project-providers', projectId, 'gateway'], [projectId]);
+    const gateway = useProjectLlmGatewayEnabled(projectId);
+    const { data } = useQuery({
+        queryKey,
+        queryFn: () => getProjectModelPicker(projectId),
+        enabled: !!projectId && gateway.enabled,
+        ...contract('config'),
+        retry: false,
+    });
+    const mutation = useMutation({
+        mutationFn: (next) => setProjectModelEnablement(projectId, next),
+        onMutate: async (next) => {
+            await queryClient.cancelQueries({ queryKey });
+            await queryClient.cancelQueries({ queryKey: providersKey });
+            const previous = queryClient.getQueryData(queryKey);
+            const previousProviders = queryClient.getQueryData(providersKey);
+            if (previous) {
+                queryClient.setQueryData(queryKey, {
+                    ...previous,
+                    models: Object.fromEntries(Object.entries(previous.models ?? {}).map(([id, model]) => [
+                        id,
+                        next[id] === undefined ? model : { ...model, enabled: next[id] },
+                    ])),
+                    modelOverrides: next,
+                    usingDefaults: Object.keys(next).length === 0,
+                });
+            }
+            if (previousProviders) {
+                queryClient.setQueryData(providersKey, applyEnablementToProviderList(previousProviders, next));
+            }
+            return { previous, previousProviders };
+        },
+        onError: (_err, _next, context) => {
+            if (context?.previous)
+                queryClient.setQueryData(queryKey, context.previous);
+            if (context?.previousProviders) {
+                queryClient.setQueryData(providersKey, context.previousProviders);
+            }
+        },
+        onSettled: () => {
+            void queryClient.invalidateQueries({ queryKey, refetchType: 'all' });
+            void queryClient.invalidateQueries({ queryKey: providersKey, refetchType: 'all' });
+        },
+    });
+    const overrides = useMemo(() => data?.modelOverrides ?? {}, [data]);
+    return {
+        usingDefaults: data?.usingDefaults ?? true,
+        defaultModel: data?.defaultModel,
+        setEnabled: useCallback(async (wireModel, enabled) => {
+            await mutation.mutateAsync({ ...overrides, [wireModel]: enabled });
+        }, [overrides, mutation]),
+        resetToDefaults: useCallback(async () => {
+            await mutation.mutateAsync({});
+        }, [mutation]),
+        isUpdating: mutation.isPending,
+    };
+}

package/dist/react/use-model-store.d.ts

@@ -0,0 +1,47 @@
+import type { ModelKey } from '../core/models/model-key.js';
+import type { FlatModel } from './model-flatten.js';
+export { modelKeyToWire, wireToModelKey, type ModelKey } from '../core/models/model-key.js';
+type Visibility = 'show' | 'hide';
+interface UserEntry extends ModelKey {
+    visibility: Visibility;
+    favorite?: boolean;
+}
+interface ModelStore {
+    user: UserEntry[];
+    recent: ModelKey[];
+    variant: Record<string, string | undefined>;
+    selectedModel?: Record<string, ModelKey | undefined>;
+    sessionAgentName?: Record<string, string | undefined>;
+    lastAgentName?: string;
+    sessionModel?: Record<string, ModelKey | undefined>;
+    globalDefault?: ModelKey;
+}
+export declare function sanitizeModelStore(raw: unknown): ModelStore;
+export declare function seedGlobalDefaultFromServer(model: ModelKey | undefined): void;
+export declare function setGlobalDefaultModel(model: ModelKey | undefined): void;
+export { computeLatestSet, hasUsableModel, isDefaultVisible } from '../core/models/model-visibility.js';
+export declare function useModelStore(allModels: FlatModel[], opts?: {
+    connectedProviderIds?: Set<string>;
+    freeTier?: boolean;
+    catalogModels?: FlatModel[];
+}): {
+    isVisible: (model: ModelKey) => boolean;
+    isLatest: (model: ModelKey) => boolean;
+    setVisibility: (model: ModelKey, show: boolean) => void;
+    resetVisibility: () => void;
+    recent: ModelKey[];
+    pushRecent: (model: ModelKey) => void;
+    getVariant: (model: ModelKey) => string | undefined;
+    setVariant: (model: ModelKey, value: string | undefined) => void;
+    getSelectedModel: (agentName: string) => ModelKey | undefined;
+    setSelectedModel: (agentName: string, model: ModelKey | undefined) => void;
+    getSessionAgentName: (sessionId: string) => string | undefined;
+    setSessionAgentName: (sessionId: string, name: string | undefined) => void;
+    lastAgentName: string | undefined;
+    setLastAgentName: (name: string | undefined) => void;
+    getSessionModel: (sessionId: string) => ModelKey | undefined;
+    setSessionModel: (sessionId: string, model: ModelKey | undefined) => void;
+    globalDefault: ModelKey | undefined;
+    setGlobalDefault: (model: ModelKey | undefined) => void;
+    userPrefs: UserEntry[];
+};