@swiss-ai-hub/web 0.290.11

package/composables/agent/useUpdateAgentInstance.ts

@@ -0,0 +1,40 @@
+import { updateAgentInstance } from '@core/sdk/client'
+
+export const useUpdateAgentInstance = defineMutation(() => {
+  const queryCache = useQueryCache()
+
+  const { mutateAsync: updateAgentInstanceMutation, isPending: isUpdating } = useMutation({
+    mutation: async ({
+      agentClass,
+      agentId,
+      tenantId,
+      configuration,
+    }: {
+      agentClass: string
+      agentId: string
+      tenantId: string
+      configuration: Record<string, unknown>
+    }) => {
+      const result = await updateAgentInstance({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId,
+          agent_class: agentClass,
+          agent_id: agentId,
+        },
+        body: {
+          configuration,
+        },
+      })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'agent-instances', agentClass, agentId] })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'agent-instances'] })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'agent-class-instances', agentClass] })
+      return result
+    },
+  })
+
+  return {
+    updateAgentInstance: updateAgentInstanceMutation,
+    isUpdating,
+  }
+})

package/composables/auth/useAuth.ts

@@ -0,0 +1,54 @@
+export const useAuth = () => {
+  const login = (idpHint?: string) => {
+    const { $auth } = useNuxtApp()
+    const extraQueryParams = idpHint ? { kc_idp_hint: idpHint } : {}
+    $auth.signinRedirect({ prompt: 'login', extraQueryParams })
+  }
+
+  const logout = async () => {
+    const { $auth, $keycloakClient } = useNuxtApp()
+    const user = await $auth.getUser()
+
+    if (user?.refresh_token) {
+      await $keycloakClient.logout(user.refresh_token)
+        .catch((error: unknown) => console.error('Keycloak session revocation failed:', error))
+    }
+
+    await $auth.removeUser()
+    navigateTo('/auth/login')
+  }
+
+  const getUser = async () => {
+    const { $auth } = useNuxtApp()
+    return await $auth.getUser()
+  }
+
+  const getToken = async () => {
+    const user = await getUser()
+    if (!user) {
+      throw new Error('User not logged in')
+    }
+    return user.access_token
+  }
+
+  const getBearer = async () => {
+    const token = await getToken()
+    return `Bearer ${token}`
+  }
+
+  const getHeaders = async (): Promise<Record<string, string>> => {
+    const bearer = await getBearer()
+    return {
+      Authorization: bearer,
+    }
+  }
+
+  return {
+    login,
+    logout,
+    getUser,
+    getToken,
+    getBearer,
+    getHeaders,
+  }
+}

package/composables/auth/useAuthProviders.ts

@@ -0,0 +1,14 @@
+import { getAuthProviders } from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+
+import type { AuthProviderResponse } from '@core/sdk/client'
+
+export const useAuthProviders = defineQuery(() => {
+  const { data: authProviders, isPending: isLoading } = useQuery<AuthProviderResponse[]>({
+    key: () => ['auth-providers'],
+    staleTime: minutesToMilliseconds(5),
+    query: async () => await getAuthProviders({ composable: '$fetch' }),
+  })
+
+  return { authProviders, isLoading }
+})

package/composables/chat/useChatCompletions.ts

@@ -0,0 +1,30 @@
+import {
+  type ChatCompletionAssistantMessageParam,
+  type ChatCompletionDeveloperMessageParam, type ChatCompletionFunctionMessageParam,
+  type ChatCompletionSystemMessageParam, type ChatCompletionToolMessageParam, type ChatCompletionUserMessageParam,
+  chatCompletionWithAssistants,
+} from '@core/sdk/client'
+
+type MessageType = Array<ChatCompletionDeveloperMessageParam | ChatCompletionSystemMessageParam | ChatCompletionUserMessageParam | ChatCompletionAssistantMessageParam | ChatCompletionToolMessageParam | ChatCompletionFunctionMessageParam>
+
+export const useChatCompletions = defineMutation(() => {
+  const { mutate: sendMessages } = useMutation({
+    mutation: ({ model, messages, threadId, tenantId }: { model: string, messages: MessageType, threadId: string, tenantId: string }) =>
+      chatCompletionWithAssistants({
+        composable: '$fetch',
+        path: { tenant_id: tenantId },
+        body: {
+          model,
+          messages,
+          stream: false,
+          metadata: {
+            thread_id: threadId,
+            reconstruct_history: true,
+          },
+        },
+      }),
+  })
+  return {
+    sendMessages,
+  }
+})

package/composables/dashboard/useAgentNameFromDashboardWidget.ts

@@ -0,0 +1,27 @@
+import type { FullAgentInstanceDto } from '@core/sdk/client'
+import type { DashboardWidget } from '@core/types/DashboardWidget'
+
+export const useAgentNameFromDashboardWidget = (widgetData: DashboardWidget) => {
+  const { agentInstances } = useAgentInstances()
+  const { t } = useI18n()
+  const agentName = computed<string>(() => {
+    const agentId = widgetData.agent?.agentId
+    const agentClass = widgetData.agent?.agentClass
+    if (!(agentId && agentClass)) {
+      return t('dashboard.all_agents')
+    }
+    if (agentClass === 'UserAgent') {
+      return t('dashboard.users')
+    }
+    const agent = agentInstances.value?.find((instance: FullAgentInstanceDto) => {
+      return instance.agent_id === agentId && instance.agent_class === agentClass
+    })
+    if (!agent) {
+      return t('dashboard.unknown_agent')
+    }
+    return agent.agent_config.name
+  })
+  return {
+    agentName,
+  }
+}

package/composables/dashboard/useDashboardComponent.ts

@@ -0,0 +1,27 @@
+import {
+  DashboardComponentNumber,
+  DashboardComponentLineChart,
+  DashboardComponentBarChart,
+} from '#components'
+
+export const useDashboardComponent = () => {
+  const mapping = {
+    DashboardComponentNumber,
+    DashboardComponentLineChart,
+    DashboardComponentBarChart,
+  }
+
+  const resolveComponent = (name: string) => {
+    if (name in mapping) {
+      return mapping[name]
+    }
+    throw Error(`Unable to resolve component for ${name}`)
+  }
+
+  const componentNames = Object.keys(mapping)
+
+  return {
+    resolveComponent,
+    componentNames,
+  }
+}

package/composables/dashboard/useSaveDashboard.ts

@@ -0,0 +1,21 @@
+import { updateMyDashboard } from '@core/sdk/client'
+
+import type { GridStackOptions } from 'gridstack/dist/types'
+
+export const useSaveDashboard = () => {
+  const queryCache = useQueryCache()
+
+  const { mutate: saveDashboard } = useMutation({
+    mutation: async ({ grid, tenantId }: { grid: GridStackOptions, tenantId: string }) => {
+      await updateMyDashboard({
+        composable: '$fetch',
+        path: { tenant_id: tenantId },
+        body: grid,
+      })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'my_user'] })
+    },
+  })
+  return {
+    saveDashboard,
+  }
+}

package/composables/document/useCreateNamespace.ts

@@ -0,0 +1,26 @@
+import { createNamespace, type CreateNamespaceRequest } from '@core/sdk/client'
+
+export const useCreateNamespace = defineMutation(() => {
+  const queryCache = useQueryCache()
+  const { tenantId } = useTenant()
+
+  return useMutation({
+    mutation: (request: CreateNamespaceRequest & { database: string, namespace: string, tenantId: string }) =>
+      createNamespace({
+        composable: '$fetch',
+        body: {
+          folder_name: request.folder_name,
+          display_name: request.display_name,
+          description: request.description,
+        },
+        path: {
+          tenant_id: request.tenantId,
+          database: request.database,
+          namespace: request.namespace,
+        },
+      }),
+    onSuccess: () => {
+      queryCache.invalidateQueries({ key: ['tenant', tenantId.value, 'knowledge'] })
+    },
+  })
+})

package/composables/document/useDatabases.ts

@@ -0,0 +1,23 @@
+import { type DatabaseDto, getDatabases } from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+
+export const useDatabases = defineQuery(() => {
+  const { tenantId } = useTenant()
+
+  const { data: databases, isPending: databasesAreLoading } = useQuery<DatabaseDto[]>({
+    key: () => ['tenant', tenantId.value, 'knowledge'],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady(),
+    query: async () => {
+      return await getDatabases({
+        composable: '$fetch',
+        path: { tenant_id: tenantId.value! },
+      })
+    },
+  })
+
+  return {
+    databases,
+    databasesAreLoading,
+  }
+})

package/composables/document/useDocument.ts

@@ -0,0 +1,29 @@
+import { type DocumentDto, getDocumentById } from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+import { useRoute } from 'vue-router'
+
+export const useDocument = defineQuery(() => {
+  const route = useRoute()
+  const { tenantId } = useTenant()
+
+  const { data: document, isPending: documentIsLoading } = useQuery<DocumentDto>({
+    key: () => ['tenant', tenantId.value, 'knowledge', 'databases', route.params.db as string, 'namespaces', route.params.namespace as string, 'documents', route.params.document_id as string],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady('db', 'namespace', 'document_id'),
+    query: async () => {
+      return await getDocumentById({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId.value!,
+          database: route.params.db as string,
+          namespace: route.params.namespace as string,
+          document_id: route.params.document_id as string,
+        },
+      })
+    },
+  })
+  return {
+    document,
+    documentIsLoading,
+  }
+})

package/composables/document/useDocumentUrl.ts

@@ -0,0 +1,20 @@
+import { getDocumentUrl } from '@core/sdk/client'
+
+export const useDocumentUrl = () => {
+  const getDocumentSourceUrl = async (tenantId: string, database: string, namespace: string, documentId: string): Promise<string> => {
+    const { url } = await getDocumentUrl({
+      composable: '$fetch',
+      path: {
+        tenant_id: tenantId,
+        database,
+        namespace,
+        document_id: documentId,
+      },
+    })
+    return url
+  }
+
+  return {
+    getDocumentSourceUrl,
+  }
+}

package/composables/document/useDocuments.ts

@@ -0,0 +1,107 @@
+import { type DocumentDto, getDocumentsForNamespace } from '@core/sdk/client'
+
+export interface SortState {
+  field: string | null
+  order: 1 | -1
+}
+
+export const useDocuments = defineQuery(() => {
+  const route = useRoute()
+  const { tenantId } = useTenant()
+
+  const currentPage = ref(1)
+  const pageSize = ref(10)
+  const searchQuery = ref<string | null>(null)
+  const sortState = ref<SortState>({ field: null, order: 1 })
+
+  const database = computed(() => route.params.db as string)
+  const namespace = computed(() => route.params.namespace as string)
+
+  const documentsQuery = useQuery({
+    key: () => ['tenant', tenantId.value, 'knowledge', 'databases', database.value, 'namespaces', namespace.value, 'documents', { page: currentPage.value, size: pageSize.value, search: searchQuery.value, sortField: sortState.value.field, sortOrder: sortState.value.order }],
+    enabled: useTenantReady('db', 'namespace'),
+    query: async () => {
+      const db = database.value
+      const ns = namespace.value
+
+      if (!db || !ns) {
+        throw new Error('Database and namespace are required')
+      }
+
+      const pageToFetch = Math.max(1, currentPage.value)
+
+      return await getDocumentsForNamespace({
+        composable: '$fetch',
+        query: {
+          page: pageToFetch,
+          page_size: pageSize.value,
+          search: searchQuery.value ?? undefined,
+          sort_field: sortState.value.field ?? undefined,
+          sort_order: sortState.value.order,
+        },
+        path: {
+          tenant_id: tenantId.value!,
+          database: db,
+          namespace: ns,
+        },
+      })
+    },
+    placeholderData: previousData => previousData,
+  })
+
+  const setPageSize = (newSize: number) => {
+    if (newSize > 0) {
+      pageSize.value = newSize
+      currentPage.value = 1
+    }
+  }
+
+  const setPage = (newPage: number) => {
+    if (newPage > 0) {
+      currentPage.value = newPage
+    }
+  }
+
+  const setSearch = (query: string | null) => {
+    searchQuery.value = query?.trim() || null
+    currentPage.value = 1
+  }
+
+  const setSort = (field: string | null, order: 1 | -1 = 1) => {
+    sortState.value = { field, order }
+    currentPage.value = 1
+  }
+
+  const paginationMeta = computed(() => {
+    const data = documentsQuery.state.value?.data
+
+    return {
+      total: data?.total ?? 0,
+      currentPage: data?.page ?? currentPage.value,
+      pageSize: data?.page_size ?? pageSize.value,
+      totalPages: data?.total_pages ?? 0,
+    }
+  })
+
+  const documents = computed(() => documentsQuery.state.value?.data?.documents ?? [] as DocumentDto[])
+
+  // Only show loading on initial load, not during refetch/search when we have data
+  const isLoading = computed(() => documentsQuery.asyncStatus.value === 'loading' && !documentsQuery.state.value?.data)
+  const isFetching = computed(() => documentsQuery.asyncStatus.value === 'loading')
+
+  return {
+    documents,
+    isLoading,
+    isFetching,
+    pagination: paginationMeta,
+    currentPage,
+    pageSize,
+    searchQuery,
+    sortState,
+    setPage,
+    setPageSize,
+    setSearch,
+    setSort,
+    refetch: documentsQuery.refetch,
+  }
+})

package/composables/document/useNodes.ts

@@ -0,0 +1,29 @@
+import { getNodesForDocument, type IngestedNode } from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+import { useRoute } from 'vue-router'
+
+export const useNodes = defineQuery(() => {
+  const route = useRoute()
+  const { tenantId } = useTenant()
+
+  const { data: nodes, isPending: nodesAreLoading } = useQuery<IngestedNode[]>({
+    key: () => ['tenant', tenantId.value, 'knowledge', 'databases', route.params.db as string, 'namespaces', route.params.namespace as string, 'documents', route.params.document_id as string, 'nodes'],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady('db', 'namespace', 'document_id'),
+    query: async () => {
+      return await getNodesForDocument({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId.value!,
+          database: route.params.db as string,
+          namespace: route.params.namespace as string,
+          document_id: route.params.document_id as string,
+        },
+      })
+    },
+  })
+  return {
+    nodes,
+    nodesAreLoading,
+  }
+})

package/composables/document/useSummaryNodes.ts

@@ -0,0 +1,32 @@
+import {
+  getSummaryNodesForDocument,
+  type NodeSummaryDto,
+} from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+import { useRoute } from 'vue-router'
+
+export const useSummaryNodes = defineQuery(() => {
+  const route = useRoute()
+  const { tenantId } = useTenant()
+
+  const { data: summaryNodes, isPending: summaryNodesAreLoading } = useQuery<NodeSummaryDto[]>({
+    key: () => ['tenant', tenantId.value, 'knowledge', 'databases', route.params.db as string, 'namespaces', route.params.namespace as string, 'documents', route.params.document_id as string, 'summaries'],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady('db', 'namespace', 'document_id'),
+    query: async () => {
+      return await getSummaryNodesForDocument({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId.value!,
+          database: route.params.db as string,
+          namespace: route.params.namespace as string,
+          document_id: route.params.document_id as string,
+        },
+      })
+    },
+  })
+  return {
+    summaryNodes,
+    summaryNodesAreLoading,
+  }
+})

package/composables/document/useUpdateNamespace.ts

@@ -0,0 +1,22 @@
+import { updateNamespace, type UpdateNamespaceRequest } from '@core/sdk/client'
+
+export const useUpdateNamespace = defineMutation(() => {
+  const queryCache = useQueryCache()
+  const { tenantId } = useTenant()
+
+  return useMutation({
+    mutation: ({ database, namespace, payload, tenantId }: { database: string, namespace: string, payload: Ref<UpdateNamespaceRequest>, tenantId: string }) =>
+      updateNamespace({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId,
+          database,
+          namespace,
+        },
+        body: payload,
+      }),
+    onSuccess: () => {
+      queryCache.invalidateQueries({ key: ['tenant', tenantId.value, 'knowledge'] })
+    },
+  })
+})

package/composables/evaluation/useCreateDataset.ts

@@ -0,0 +1,19 @@
+import { createDataset as createDatasetCall, type DatasetCreate } from '@core/sdk/client'
+
+export const useCreateDataset = () => {
+  const queryCache = useQueryCache()
+
+  const { mutateAsync: createDataset } = useMutation({
+    mutation: async ({ dataset, tenantId }: { dataset: DatasetCreate, tenantId: string }) => {
+      await createDatasetCall({
+        composable: '$fetch',
+        path: { tenant_id: tenantId },
+        body: dataset,
+      })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'datasets'] })
+    },
+  })
+  return {
+    createDataset,
+  }
+}

package/composables/evaluation/useDataset.ts

@@ -0,0 +1,26 @@
+import { type Dataset, getDataset } from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+
+export const useDataset = defineQuery(() => {
+  const route = useRoute()
+  const { tenantId } = useTenant()
+
+  const { data: dataset, isPending: datasetIsLoading } = useQuery<Dataset>({
+    key: () => ['tenant', tenantId.value, 'datasets', route.params.dataset_id as string],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady('dataset_id'),
+    query: async () => {
+      return await getDataset({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId.value!,
+          dataset_id: route.params.dataset_id as string,
+        },
+      })
+    },
+  })
+  return {
+    dataset,
+    datasetIsLoading,
+  }
+})

package/composables/evaluation/useDatasets.ts

@@ -0,0 +1,25 @@
+import {
+  getDatasets,
+  type MinimalDataset,
+} from '@core/sdk/client'
+import { minutesToMilliseconds } from 'date-fns'
+
+export const useDatasets = defineQuery(() => {
+  const { tenantId } = useTenant()
+
+  const { data: datasets, isPending: datasetsAreLoading } = useQuery<MinimalDataset[]>({
+    key: () => ['tenant', tenantId.value, 'datasets'],
+    staleTime: minutesToMilliseconds(5),
+    enabled: useTenantReady(),
+    query: async () => {
+      return await getDatasets({
+        composable: '$fetch',
+        path: { tenant_id: tenantId.value! },
+      })
+    },
+  })
+  return {
+    datasets,
+    datasetsAreLoading,
+  }
+})

package/composables/evaluation/useUpdateDataset.ts

@@ -0,0 +1,23 @@
+import { type DatasetUpdate, updateDataset as updateDatasetCall } from '@core/sdk/client'
+
+export const useUpdateDataset = () => {
+  const queryCache = useQueryCache()
+  const route = useRoute()
+
+  const { mutateAsync: updateDataset } = useMutation({
+    mutation: async ({ dataset, tenantId }: { dataset: DatasetUpdate, tenantId: string }) => {
+      await updateDatasetCall({
+        composable: '$fetch',
+        body: dataset,
+        path: {
+          tenant_id: tenantId,
+          dataset_id: route.params.dataset_id as string,
+        },
+      })
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'datasets'] })
+    },
+  })
+  return {
+    updateDataset,
+  }
+}