@swiss-ai-hub/web 0.320.0 → 0.321.0

package/components/Role/AccessCapabilities.vue

@@ -21,8 +21,8 @@
         :group="group"
         :depth="0"
         :readonly="readonly"
-        @add="(rule) => emit('add', rule)"
-        @remove="(rule) => emit('remove', rule)"
+        @add="(rules) => emit('add', rules)"
+        @remove="(rules) => emit('remove', rules)"
       />
     </div>
     <p
@@ -55,8 +55,8 @@ const props = withDefaults(defineProps<{
 })
 
 const emit = defineEmits<{
-  add: [rule: string]
-  remove: [rule: string]
+  add: [rules: string[]]
+  remove: [rules: string[]]
 }>()
 
 const { capabilities, capabilitiesAreLoading } = useAccessCapabilities(

package/components/Role/AccessCapabilityGroup.vue

@@ -78,8 +78,9 @@
         </span>
         <code
           v-if="cap.rule"
+          v-tooltip.top="ruleTooltip(cap)"
           class="mt-0.5 shrink-0 font-mono text-[11px] text-surface-300 transition-colors group-hover/cap:text-surface-500 dark:text-surface-600 dark:group-hover/cap:text-surface-400"
-        >{{ cap.rule }}</code>
+        >{{ cap.companion_rules?.length ? `${cap.rule} +${cap.companion_rules.length}` : cap.rule }}</code>
       </label>
     </div>
 
@@ -95,8 +96,8 @@
         :group="sub"
         :depth="depth + 1"
         :readonly="readonly"
-        @add="(rule) => emit('add', rule)"
-        @remove="(rule) => emit('remove', rule)"
+        @add="(rules) => emit('add', rules)"
+        @remove="(rules) => emit('remove', rules)"
       />
     </div>
   </div>
@@ -119,12 +120,27 @@ const props = withDefaults(defineProps<{
 })
 
 const emit = defineEmits<{
-  add: [rule: string]
-  remove: [rule: string]
+  add: [rules: string[]]
+  remove: [rules: string[]]
 }>()
 
+// Two lists, two meanings. `companion_rules` is written and cleared with the row — a knowledge database
+// owns its namespaces, and the grammar has no single form covering a node and its subtree, so that row
+// needs both. `revoked_rules` is only ever cleared: an agent class does not own the profiles built from it,
+// so ticking must never write `<class>.>`, while unticking still takes an old ceiling's copy of it. Each
+// direction emits one payload because the parent writes them through a single `v-model`, which cannot
+// absorb two writes in the same tick — the second would read a model value the first had not yet updated.
+// The badge counts only what ticking grants; what unticking additionally takes is left to the tooltip.
+const ruleTooltip = (cap: Capability) =>
+  [
+    cap.companion_rules?.length ? t('role.capability_also_granted', { rules: cap.companion_rules.join(', ') }) : null,
+    cap.revoked_rules?.length ? t('role.capability_also_cleared', { rules: cap.revoked_rules.join(', ') }) : null,
+  ].filter(Boolean).join('\n') || undefined
+
 const onToggle = (cap: Capability, value: boolean) => {
   if (props.readonly || !cap.rule) return
-  emit(value ? 'add' : 'remove', cap.rule)
+  const granted = [cap.rule, ...(cap.companion_rules ?? [])]
+  if (value) emit('add', granted)
+  else emit('remove', [...granted, ...(cap.revoked_rules ?? [])])
 }
 </script>

package/components/Role/AccessRulesEditor.vue

@@ -70,7 +70,7 @@
               variant="text"
               rounded
               size="small"
-              @click="remove(data.accessRule)"
+              @click="removeRules([data.accessRule])"
             />
           </template>
         </Column>
@@ -123,7 +123,7 @@
               type="button"
               class="flex flex-col items-start gap-1 rounded-md p-2 text-left hover:bg-surface-100 disabled:opacity-40 dark:hover:bg-surface-800"
               :disabled="rules.includes(preset.rule)"
-              @click="addPreset(preset.rule)"
+              @click="addRules([preset.rule])"
             >
               <span class="flex items-center gap-2 text-sm font-medium">
                 {{ preset.name }}
@@ -147,8 +147,8 @@
     <AccessCapabilities
       :rules="rules"
       :restrict-to-tenant="restrictToTenant"
-      @add="addPreset"
-      @remove="remove"
+      @add="addRules"
+      @remove="removeRules"
     />
   </div>
 </template>
@@ -197,17 +197,20 @@ const newRule = ref('')
 
 const isNew = (rule: string) => !props.initialRules.includes(rule)
 
-const add = () => {
-  if (!newRule.value) return
-  if (!rules.value.includes(newRule.value)) rules.value.push(newRule.value)
-  newRule.value = ''
+// Both write the model once per call, never once per rule: `rules` is a `defineModel`, so a second write in
+// the same tick would still read the value the first one replaced. Assignment rather than in-place mutation
+// for the same reason — a parent binding this through a computed never observes a mutated array.
+const addRules = (added: string[]) => {
+  rules.value = [...rules.value, ...added.filter(rule => !rules.value.includes(rule))]
 }
 
-const addPreset = (rule: string) => {
-  if (!rules.value.includes(rule)) rules.value.push(rule)
+const removeRules = (removed: string[]) => {
+  rules.value = rules.value.filter(rule => !removed.includes(rule))
 }
 
-const remove = (rule: string) => {
-  rules.value = rules.value.filter(r => r !== rule)
+const add = () => {
+  if (!newRule.value) return
+  addRules([newRule.value])
+  newRule.value = ''
 }
 </script>

package/composables/app/useAppVersion.ts

@@ -1,34 +1,32 @@
 import { getHealth } from '@core/sdk/client'
 import { minutesToMilliseconds } from 'date-fns'
 
-// Surfaces the running version of both services. The UI service version is baked
-// into the static bundle at build time (runtimeConfig.public.appVersion); the API
-// version is read from the health endpoint. When both agree a single number is
-// shown, otherwise both are shown as `UI / API`.
+// Surfaces the running version of both services. When both name the same release
+// a single version is shown, otherwise both are shown as `UI / API` so a genuine
+// skew — one service rolled, the other not — stays visible.
 //
-// A release is promoted by retagging the exact `-rc.N` build that was tested, so
-// the baked UI version keeps its release-candidate suffix (e.g. `v0.317.0-rc.3`)
-// even though the artifact IS the final release. A container cannot read its own
-// image tag, so the release has to be inferred from what the API reports, and the
-// two deployment flavours report it differently: docker-compose pins the channel
-// tag (`latest`), while Helm pins an exact `vX.Y.Z` per instance and leaves the
-// API on its package metadata (`0.319.0`). Both are release signals; on either
-// one the suffix is dropped so a promoted build shows its release version.
+// Neither container can know its own version at build time: a release is promoted
+// by retagging the exact `-rc.N` build that was tested, so anything baked into an
+// image keeps the candidate's name even though the artifact IS the final release.
+// The deployment is the only party that knows the tag it pulled, so both sides
+// take their version from it — the UI through APP_VERSION in /config.js (see
+// plugins/0.runtime-config.client.ts), the API through its AIHUB_VERSION env var.
+// Each falls back to its build-time value when the deployment injects nothing,
+// which is why a promoted build can still report `-rc.N` on one side only.
 //
-// Versions are compared with the leading `v` normalised away, because one side is
-// a git tag (`v0.319.0`) and the other Python package metadata (`0.319.0`) — the
-// same version, and rendering it as `UI / API` would read as skew.
+// docker-compose is the one flavour that pins a rolling channel tag instead of an
+// exact version, so it reports the channel name (`latest`) rather than a number.
 //
-// Every other case is genuinely a candidate or a rolling build (another channel
-// such as `staging`, an API pinned to an explicit `-rc.N`, a nightly), so the
-// suffix stays to keep the build identifiable.
+// Versions are compared with the leading `v` normalised away, because one side is
+// a git tag (`v0.319.0`) and the other can be Python package metadata (`0.319.0`)
+// — the same version, and rendering it as `UI / API` would read as skew.
 const RELEASE_CHANNEL = 'latest'
 const RC_SUFFIX = /-rc\.\d+$/
 const toReleaseVersion = (version: string): string => version.replace(RC_SUFFIX, '')
-const toComparable = (version: string): string => version.replace(/^v/, '')
+const toComparable = (version: string): string => toReleaseVersion(version.replace(/^v/, ''))
 
 export const useAppVersion = defineQuery(() => {
-  const bakedUiVersion = useRuntimeConfig().public.appVersion as string
+  const declaredUiVersion = useRuntimeConfig().public.appVersion as string
 
   const { data: apiVersion } = useQuery<string>({
     key: () => ['app-version', 'api'],
@@ -39,23 +37,23 @@ export const useAppVersion = defineQuery(() => {
     },
   })
 
-  // An API version that still carries `-rc.N` can never equal the stripped UI
-  // version, so a candidate deployment fails this check without a separate guard.
-  const isReleaseDeployment = computed(() => {
+  // The one version both services agree on, or null when they genuinely differ.
+  const agreedVersion = computed(() => {
     const api = apiVersion.value
-    if (!api) return false
-    return api === RELEASE_CHANNEL || toComparable(api) === toComparable(toReleaseVersion(bakedUiVersion))
+    if (!api) return declaredUiVersion
+    if (api === RELEASE_CHANNEL) return toReleaseVersion(declaredUiVersion)
+    if (toComparable(api) !== toComparable(declaredUiVersion)) return null
+    // Same release. If either side reports the promoted, suffix-free name then
+    // that is what this deployment is; if both still carry `-rc.N` it really is a
+    // candidate build and the suffix stays to keep it identifiable.
+    return RC_SUFFIX.test(declaredUiVersion) ? api : declaredUiVersion
   })
 
-  const uiVersion = computed(() =>
-    isReleaseDeployment.value ? toReleaseVersion(bakedUiVersion) : bakedUiVersion,
-  )
+  const uiVersion = computed(() => agreedVersion.value ?? declaredUiVersion)
 
-  const versionDisplay = computed(() => {
-    const api = apiVersion.value
-    if (!api || toComparable(api) === toComparable(uiVersion.value)) return uiVersion.value
-    return `${uiVersion.value} / ${api}`
-  })
+  const versionDisplay = computed(
+    () => agreedVersion.value ?? `${declaredUiVersion} / ${apiVersion.value}`,
+  )
 
   return { uiVersion, apiVersion, versionDisplay }
 })

package/composables/auth/useAuth.ts

@@ -2,20 +2,12 @@ export const useAuth = () => {
   const login = (idpHint?: string) => {
     const { $auth } = useNuxtApp()
     const extraQueryParams = idpHint ? { kc_idp_hint: idpHint } : {}
-    $auth.signinRedirect({ prompt: 'login', extraQueryParams })
+    $auth.signinRedirect({ 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 { $auth } = useNuxtApp()
+    await $auth.signoutRedirect()
   }
 
   const getUser = async () => {

package/composables/document/useCreateDatabase.ts

@@ -0,0 +1,21 @@
+import { createDatabase, type CreateDatabaseRequest } from '@core/sdk/client'
+
+export const useCreateDatabase = defineMutation(() => {
+  const queryCache = useQueryCache()
+  const { tenantId } = useTenant()
+
+  return useMutation({
+    mutation: (params: { database: string, tenantId: string, request: CreateDatabaseRequest }) =>
+      createDatabase({
+        composable: '$fetch',
+        body: params.request,
+        path: {
+          tenant_id: params.tenantId,
+          database: params.database,
+        },
+      }),
+    onSuccess: () => {
+      queryCache.invalidateQueries({ key: ['tenant', tenantId.value, 'knowledge'] })
+    },
+  })
+})

package/composables/document/useDeleteDatabase.ts

@@ -0,0 +1,29 @@
+import { deleteDatabase } from '@core/sdk/client'
+
+export const useDeleteDatabase = defineMutation(() => {
+  const queryCache = useQueryCache()
+
+  const {
+    mutateAsync: deleteDatabaseMutation,
+    isLoading: isDeleting,
+    error: deleteError,
+  } = useMutation({
+    mutation: async ({ tenantId, database }: { tenantId: string, database: string }) => {
+      await deleteDatabase({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId,
+          database,
+        },
+      })
+
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'knowledge'] })
+    },
+  })
+
+  return {
+    deleteDatabase: deleteDatabaseMutation,
+    isDeleting,
+    deleteError,
+  }
+})

package/composables/document/useDeleteDocument.ts

@@ -5,7 +5,7 @@ export const useDeleteDocument = defineMutation(() => {
 
   const {
     mutateAsync: deleteDocumentMutation,
-    isPending: isDeleting,
+    isLoading: isDeleting,
     error: deleteError,
   } = useMutation({
     mutation: async ({ tenantId, database, namespace, documentId }: { tenantId: string, database: string, namespace: string, documentId: string }) => {

package/composables/document/useDeleteDocuments.ts

@@ -7,7 +7,7 @@ export const useDeleteDocuments = defineMutation(() => {
 
   const {
     mutateAsync: deleteDocumentsMutation,
-    isPending: isDeleting,
+    isLoading: isDeleting,
     error: deleteError,
   } = useMutation({
     mutation: async ({ tenantId, database, namespace, documentIds }: { tenantId: string, database: string, namespace: string, documentIds: string[] }): Promise<BatchDeleteDocumentsResponse> => {

package/composables/document/useDeleteNamespace.ts

@@ -0,0 +1,30 @@
+import { deleteNamespace } from '@core/sdk/client'
+
+export const useDeleteNamespace = defineMutation(() => {
+  const queryCache = useQueryCache()
+
+  const {
+    mutateAsync: deleteNamespaceMutation,
+    isLoading: isDeleting,
+    error: deleteError,
+  } = useMutation({
+    mutation: async ({ tenantId, database, namespace }: { tenantId: string, database: string, namespace: string }) => {
+      await deleteNamespace({
+        composable: '$fetch',
+        path: {
+          tenant_id: tenantId,
+          database,
+          namespace,
+        },
+      })
+
+      queryCache.invalidateQueries({ key: ['tenant', tenantId, 'knowledge'] })
+    },
+  })
+
+  return {
+    deleteNamespace: deleteNamespaceMutation,
+    isDeleting,
+    deleteError,
+  }
+})

package/composables/document/useIngestors.ts

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

package/composables/form/useCreateInstanceForm.ts

@@ -115,9 +115,9 @@ export function useCreateInstanceForm<T extends ClassDataLike>(options: CreateIn
 
   function resetForm() {
     selectedClass.value = initialClass()
-    formData.value = {}
+    formData.value = hydrateFormData({}, configForm.value as FormElement[])
     activeStep.value = 0
-    seededForClass = null
+    seededForClass = selectedClassData.value ? selectedClass.value : null
   }
 
   return {

package/composables/form/useFormKitTransform.ts

@@ -339,15 +339,25 @@ function nullableToggleId(element: FormElement): string {
 
 /**
  * Combines a synthetic toggle condition with any existing condition_if.
+ *
+ * The `$` on every `$get(...)` must survive. `$:` marks the string as an expression; it does not put the
+ * references inside it into scope. Stripping their `$` made FormKit's compiler see a bare `get`, which it
+ * treats as a literal rather than a provided function — the expression then evaluated to the truthy string
+ * `"0{[nativecode]}.value"`, so a gated field rendered unconditionally and neither checkbox could hide it.
  */
 function combineConditions(toggleCondition: string, existing: string | undefined): string {
   if (!existing) return toggleCondition
-  if (existing.startsWith('$:')) {
-    return `$: ${toggleCondition.slice(1)} && (${existing.slice(2).trim()})`
-  }
-  return `$: ${toggleCondition.slice(1)} && (${existing.slice(1)})`
+  const existingExpression = existing.startsWith('$:') ? existing.slice(2).trim() : existing
+  return `$: ${toggleCondition} && (${existingExpression})`
 }
 
+/**
+ * The toggle inherits the element's own `condition_if` so it disappears with the section it belongs to.
+ * Without this, a nullable field gated on a sibling checkbox (e.g. the memory model, which only applies
+ * while memory storage is on) would hide its input but leave a stray "Enable X" checkbox behind.
+ * The element's nullable-toggle condition is deliberately NOT inherited — that is the condition this very
+ * node controls.
+ */
 function buildNullableToggleNode(
   element: FormElement,
   label: string | undefined,
@@ -355,13 +365,19 @@ function buildNullableToggleNode(
 ): Record<string, unknown> {
   const fieldName = element.name as string
   const toggleId = nullableToggleId(element)
+  const gatingCondition = element.if as string | undefined
   return {
     $formkit: 'primeCheckbox',
+    // `preserve: true` for the same reason the gated input itself carries it: when this toggle's own
+    // condition unmounts it, FormKit would otherwise drop `__<field>__enabled` from the group data, and the
+    // state seeded from the saved value is lost — an already-configured field then remounts reading "off".
+    preserve: true,
     name: nullableToggleName(fieldName),
     id: toggleId,
     key: toggleId,
     label: label ? `Enable ${label}` : 'Enable',
     ...(help ? { help } : {}),
+    ...(gatingCondition ? { if: gatingCondition } : {}),
     binary: true,
   }
 }
@@ -682,17 +698,18 @@ export function coerceNullableToggles(
 }
 
 /**
- * Recursively fills missing leaf keys with the backend's serialised Pydantic defaults
- * (`element.value`). FormKit no longer receives `value` in the schema (it would clobber
- * the v-model on registration), so defaults must be merged into the form data instead.
- * Existing values — including falsy ones like `false` or `""` — are preserved.
- *
- * NOTE: This helper is load-bearing for edit/clone/template flows but has no direct
- * unit tests yet — Vitest is not configured for packages/web (see packages/web/CLAUDE.md).
- * The Python-side `Form.to_formkit_form()` tests in packages/core lock in what
- * `element.value` looks like; behaviour here is exercised end-to-end on agent and
- * process edit forms.
+ * A nullable leaf stored as `null` is seeded with its default too, mirroring how `seedGroupDefault`
+ * materialises a null nullable group: `null` means "the toggle is off", not "the input holds nothing",
+ * so the field behind the toggle should still offer the default the backend ships (e.g. the memory
+ * model starting on the platform-wide one). Safe in both directions — `seedNullableToggles` has
+ * already decided the toggle from the raw null-ness, so this cannot switch one on, and
+ * `coerceNullableToggles` re-nullifies a disabled field at submit time, so the seeded value is never
+ * persisted while the toggle is off.
  */
+function isDisabledNullableLeaf(element: FormElement, value: unknown): boolean {
+  return element.nullable === true && value === null
+}
+
 /**
  * Seed a group field's value: always materialise its children's defaults (starting from
  * the existing object when present, `{}` otherwise — including for a saved `null`). A null
@@ -726,6 +743,18 @@ function seedRepeaterDefault(value: unknown, children: FormElement[]): unknown {
   return value === undefined ? [] : value
 }
 
+/**
+ * Recursively fills missing leaf keys with the backend's serialised Pydantic defaults
+ * (`element.value`). FormKit no longer receives `value` in the schema (it would clobber
+ * the v-model on registration), so defaults must be merged into the form data instead.
+ * Existing values — including falsy ones like `false` or `""` — are preserved.
+ *
+ * NOTE: This helper is load-bearing for edit/clone/template flows but has no direct
+ * unit tests yet — Vitest is not configured for packages/web (see packages/web/CLAUDE.md).
+ * The Python-side `Form.to_formkit_form()` tests in packages/core lock in what
+ * `element.value` looks like; behaviour here is exercised end-to-end on agent and
+ * process edit forms.
+ */
 export function seedFormDefaults(
   data: Record<string, unknown>,
   elements: FormElement[],
@@ -744,7 +773,7 @@ export function seedFormDefaults(
     else if (formkitType === 'repeater') {
       result[name] = seedRepeaterDefault(value, children)
     }
-    else if (!(name in result) && element.value !== undefined) {
+    else if (element.value !== undefined && (!(name in result) || isDisabledNullableLeaf(element, value))) {
       result[name] = element.value
     }
   }

package/formkit.config.ts

@@ -32,6 +32,21 @@ function localeRequired(node: FormKitNode): boolean {
 // create form: precisely the case this rule exists to catch.
 localeRequired.skipEmpty = false
 
+// Same shape of problem for agentSelector: its value is always an `{agent_class, agent_id}` object,
+// so picking a class alone yields a non-empty object with a blank `agent_id` that `required` accepts.
+// A blank id then renders as a NATS wildcard at runtime and the delegation reaches no agent at all.
+// Backend `AgentSelector` elements emit `agentRefRequired` instead
+// (see packages/core/swiss_ai_hub/core/form/elements/agent_selector.py).
+function agentRefRequired(node: FormKitNode): boolean {
+  const value = node.value as { agent_class?: string | null, agent_id?: string | null } | null | undefined
+  if (!value) return false
+  return !!value.agent_class?.trim() && !!value.agent_id?.trim()
+}
+
+// As with localeRequired: without this the rule never runs on a never-touched field, whose value is
+// still `null`, so a fresh create form would submit with no agent selected at all.
+agentRefRequired.skipEmpty = false
+
 /**
  * Passes when the value is listed in the sibling field named by `address`, or when that list is
  * empty — backend allow-lists treat empty as unrestricted. Reading the sibling through `node.at()`
@@ -54,6 +69,13 @@ const localeRequiredMessages = {
   it: 'Almeno una lingua deve essere compilata.',
 }
 
+const agentRefRequiredMessages = {
+  de: 'Bitte wählen Sie einen Agententyp und ein Agentenprofil aus.',
+  en: 'Please select both an agent type and an agent profile.',
+  fr: 'Veuillez sélectionner un type d\'agent et un profil d\'agent.',
+  it: 'Seleziona sia un tipo di agente sia un profilo di agente.',
+}
+
 const memberOfMessages = {
   de: 'Dieser Wert steht nicht in der Liste der erlaubten Werte.',
   en: 'This value is not in the allowed list.',
@@ -62,11 +84,12 @@ const memberOfMessages = {
 }
 
 const config: DefaultConfigOptions = {
-  rules: { localeRequired, memberOf },
+  rules: { localeRequired, agentRefRequired, memberOf },
   messages: Object.fromEntries(
     LOCALES.map(locale => [locale, {
       validation: {
         localeRequired: localeRequiredMessages[locale],
+        agentRefRequired: agentRefRequiredMessages[locale],
         memberOf: memberOfMessages[locale],
       },
     }]),