Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
19.3 KB
Raw Blame
'use client'

import React, { useEffect, useMemo, useRef, useState } from 'react'
import {
  ConfirmationDialog,
  DataTable,
  GroupedTableBody,
  TableStateRow,
  TableViewport,
  useTableSort,
} from '@clerum/frontend-components'
import { LlmProviderIcon } from '@components/LlmProviderIcon'
import { IconModels } from '@components/Sidebar/icons'
import { TableHeaderRow } from '@components/TableHeaderRow'
import type { TableHeaderColumn } from '@components/TableHeaderRow/types'
import { TablePanelHeader } from '@components/TablePanelHeader'
import { useToast } from '@components/Toast'
import { IconRefresh } from '@components/icons'
import {
  type LlmAllowedModel,
  type LlmDiscoveryStatus,
  getDiscoveryStatus,
  isLlmModelConfigMapDeferred,
  isSilentApiError,
  syncDiscovery,
  updateLlmModel,
} from '@lib/api'
import { catalogGroupKey, formatContextWindow, getProviderDisplayLabel } from '@lib/llm'
import type { LlmDiscoveryPanelProps } from './types'

const CONFIGMAP_DEFERRED_WARNING =
  'Propagation to the cluster is delayed and will reconcile shortly.'

type ReviewSortKey = 'provider' | 'model' | 'vendor' | 'contextWindow'

function modelLabel(model: LlmAllowedModel): string {
  return `${getProviderDisplayLabel(model.provider)}/${model.model}`
}

function formatRunAt(value: string | null | undefined): string {
  if (!value) return ''
  const date = new Date(value)
  return Number.isNaN(date.getTime()) ? value : date.toLocaleString()
}

export function LlmDiscoveryPanel({
  items,
  loading,
  navigation,
  onRefresh,
}: LlmDiscoveryPanelProps) {
  const { showToast } = useToast()

  const [status, setStatus] = useState<LlmDiscoveryStatus | null>(null)
  const [statusLoading, setStatusLoading] = useState(false)
  const [error, setError] = useState('')
  const [syncing, setSyncing] = useState(false)
  const [pendingId, setPendingId] = useState<string | null>(null)
  const [bulkEnabling, setBulkEnabling] = useState(false)
  const [expandedProviders, setExpandedProviders] = useState<Set<string>>(new Set())
  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set())
  const [enableConfirmation, setEnableConfirmation] = useState<
    { kind: 'single'; model: LlmAllowedModel } | { kind: 'bulk' } | null
  >(null)
  const statusRequestGeneration = useRef(0)

  const isInitialLoad = loading && items.length === 0
  const reviewQueue = useMemo(
    () => items.filter(model => model.source === 'discovery' && !model.enabled && !model.stale),
    [items]
  )
  const reviewSort = useTableSort<LlmAllowedModel, ReviewSortKey>({
    rows: reviewQueue,
    defaultKey: 'provider',
    defaultDirections: { contextWindow: 'desc' },
    identity: model => model.id,
    accessors: {
      provider: model => getProviderDisplayLabel(model.provider),
      model: model => model.model,
      vendor: model => model.vendor,
      contextWindow: model => model.context_window_tokens,
    },
  })

  const selectedCount = useMemo(
    () => reviewQueue.reduce((count, model) => (selectedIds.has(model.id) ? count + 1 : count), 0),
    [reviewQueue, selectedIds]
  )
  const allSelected = reviewQueue.length > 0 && selectedCount === reviewQueue.length
  const groupedReviewRows = useMemo(() => {
    const groups = new Map<string, LlmAllowedModel[]>()
    for (const model of reviewSort.sortedRows) {
      const provider = catalogGroupKey(model.provider)
      const group = groups.get(provider)
      if (group) group.push(model)
      else groups.set(provider, [model])
    }
    return Array.from(groups.entries()).sort(([left], [right]) =>
      getProviderDisplayLabel(left).localeCompare(getProviderDisplayLabel(right))
    )
  }, [reviewSort.sortedRows])

  function setProviderExpanded(provider: string, expanded: boolean) {
    setExpandedProviders(current => {
      const next = new Set(current)
      if (expanded) next.add(provider)
      else next.delete(provider)
      return next
    })
  }

  useEffect(() => {
    let active = true
    const generation = ++statusRequestGeneration.current
    setStatusLoading(true)
    void getDiscoveryStatus()
      .then(nextStatus => {
        if (active && generation === statusRequestGeneration.current) setStatus(nextStatus)
      })
      .catch(() => {
        // Status is optional while older control-api builds roll forward.
      })
      .finally(() => {
        if (active && generation === statusRequestGeneration.current) setStatusLoading(false)
      })
    return () => {
      active = false
    }
  }, [])

  useEffect(() => {
    const currentIds = new Set(reviewQueue.map(model => model.id))
    setSelectedIds(previous => {
      const next = new Set(Array.from(previous).filter(id => currentIds.has(id)))
      return next.size === previous.size ? previous : next
    })
  }, [reviewQueue])

  function toggleRow(id: string) {
    setSelectedIds(previous => {
      const next = new Set(previous)
      if (next.has(id)) next.delete(id)
      else next.add(id)
      return next
    })
  }

  function toggleAll() {
    setSelectedIds(previous => {
      if (reviewQueue.length > 0 && reviewQueue.every(model => previous.has(model.id))) {
        return new Set()
      }
      return new Set(reviewQueue.map(model => model.id))
    })
  }

  async function handleRefresh() {
    const generation = ++statusRequestGeneration.current
    setStatusLoading(true)
    setError('')
    try {
      const [, statusResult] = await Promise.allSettled([onRefresh(), getDiscoveryStatus()])
      if (generation === statusRequestGeneration.current && statusResult.status === 'fulfilled') {
        setStatus(statusResult.value)
      }
    } finally {
      if (generation === statusRequestGeneration.current) setStatusLoading(false)
    }
  }

  async function handleSync() {
    const generation = ++statusRequestGeneration.current
    setSyncing(true)
    setError('')
    try {
      const result = await syncDiscovery()
      await onRefresh()
      if (generation === statusRequestGeneration.current) {
        setStatus({
          ranAt: result.ranAt,
          source: result.source,
          added: result.added,
          updated: result.updated,
          staled: result.staled,
        })
      }
      showToast(
        `Synced from ${result.source}: +${result.added} new, ${result.updated} updated, ${result.staled} marked stale`,
        { tone: 'success' }
      )
    } catch (caught) {
      if (isSilentApiError(caught)) return
      const message = caught instanceof Error ? caught.message : 'Discovery sync failed'
      setError(message)
      showToast(message, { tone: 'error' })
    } finally {
      if (generation === statusRequestGeneration.current) setStatusLoading(false)
      setSyncing(false)
    }
  }

  async function handleEnable(model: LlmAllowedModel) {
    const label = modelLabel(model)
    setPendingId(model.id)
    setError('')
    try {
      await updateLlmModel(model.id, { enabled: true })
      await onRefresh()
      showToast(`${label} enabled.`, { tone: 'success' })
    } catch (caught) {
      if (isSilentApiError(caught)) return
      if (isLlmModelConfigMapDeferred(caught)) {
        await onRefresh()
        showToast(`${label} enabled. ${CONFIGMAP_DEFERRED_WARNING}`, { tone: 'info' })
        return
      }
      const message = caught instanceof Error ? caught.message : `Failed to enable ${label}`
      setError(message)
      showToast(message, { tone: 'error' })
    } finally {
      setPendingId(null)
    }
  }

  async function handleBulkEnable() {
    const targets = reviewQueue.filter(model => selectedIds.has(model.id))
    if (targets.length === 0) return

    setBulkEnabling(true)
    setError('')
    let results: PromiseSettledResult<unknown>[] = []
    try {
      results = await Promise.allSettled(
        targets.map(model => updateLlmModel(model.id, { enabled: true }))
      )
      setSelectedIds(new Set())
      await onRefresh()
    } finally {
      setBulkEnabling(false)
    }

    if (results.some(result => result.status === 'rejected' && isSilentApiError(result.reason))) {
      return
    }
    const deferred = results.some(
      result => result.status === 'rejected' && isLlmModelConfigMapDeferred(result.reason)
    )
    const hardFailures = results.filter(
      result => result.status === 'rejected' && !isLlmModelConfigMapDeferred(result.reason)
    ).length
    const succeeded = targets.length - hardFailures
    if (hardFailures === 0) {
      showToast(
        `Enabled ${succeeded} model${succeeded === 1 ? '' : 's'}.${
          deferred ? ` ${CONFIGMAP_DEFERRED_WARNING}` : ''
        }`,
        { tone: deferred ? 'info' : 'success' }
      )
      return
    }

    const message = `Enabled ${succeeded} of ${targets.length} models; ${hardFailures} failed.`
    setError(message)
    showToast(message, { tone: 'error' })
  }

  function confirmEnable() {
    const confirmation = enableConfirmation
    setEnableConfirmation(null)
    if (confirmation?.kind === 'single') void handleEnable(confirmation.model)
    if (confirmation?.kind === 'bulk') void handleBulkEnable()
  }

  const reviewColumns: TableHeaderColumn[] = (
    [
      {
        key: 'select',
        width: '2.75rem',
        label: (
          <input
            type="checkbox"
            checked={allSelected}
            ref={element => {
              if (element) element.indeterminate = selectedCount > 0 && !allSelected
            }}
            onChange={toggleAll}
            disabled={reviewQueue.length === 0 || bulkEnabling}
            aria-label={allSelected ? 'Deselect all review models' : 'Select all review models'}
          />
        ),
      },
      { key: 'model', label: 'Model', minWidth: '12rem' },
      { key: 'vendor', label: 'Vendor', width: '10rem' },
      {
        key: 'contextWindow',
        label: 'Context window',
        align: 'right',
        width: '9rem',
      },
      { key: 'actions', width: '7rem', align: 'right', ariaLabel: 'Actions' },
    ] satisfies TableHeaderColumn[]
  ).map(column =>
    column.key === 'select' || column.key === 'actions'
      ? column
      : {
          ...column,
          activeDirection: reviewSort.key === column.key ? reviewSort.direction : null,
          defaultDirection: column.key === 'contextWindow' ? 'desc' : 'asc',
          onSort: () => reviewSort.sortBy(column.key as ReviewSortKey),
        }
  )

  const providerColumns: TableHeaderColumn[] = [
    { key: 'provider', label: 'Provider' },
    { key: 'models', label: 'Models' },
    { key: 'details', label: 'Details' },
    { key: 'actions', label: 'Actions', align: 'right' },
  ]

  return (
    <>
      {error ? (
        <div className="cu-banner cu-banner--error cu-llm-models-error" role="alert">
          {error}
        </div>
      ) : null}

      <div className="cu-card cu-card--viewport-fill cu-section-card">
        <TablePanelHeader
          title={
            <>
              <IconModels />
              LLM Models
            </>
          }
          subtitle="Newly synced models land here disabled. Enable only the models you want available to agents and runtime."
          secondaryActions={
            selectedCount > 0 ? (
              <>
                <button
                  type="button"
                  className="cu-btn cu-btn--ghost cu-btn--sm"
                  onClick={() => setSelectedIds(new Set())}
                  disabled={bulkEnabling}
                >
                  Unselect all
                </button>
                <button
                  type="button"
                  className="cu-btn cu-btn--primary cu-btn--sm"
                  onClick={() => setEnableConfirmation({ kind: 'bulk' })}
                  disabled={bulkEnabling}
                >
                  {bulkEnabling ? 'Enabling…' : `Enable ${selectedCount} selected`}
                </button>
              </>
            ) : undefined
          }
          primaryAction={
            <button
              type="button"
              className="cu-btn cu-btn--primary cu-btn--sm"
              onClick={() => void handleSync()}
              disabled={syncing || isInitialLoad}
            >
              {syncing ? 'Syncing…' : 'Sync catalog'}
            </button>
          }
          refreshAction={
            <button
              type="button"
              className="cu-btn cu-btn--icon cu-btn--toolbar"
              onClick={() => void handleRefresh()}
              disabled={loading || statusLoading || isInitialLoad}
              aria-label={loading || statusLoading ? 'Refreshing…' : 'Reload discovery review'}
            >
              <IconRefresh
                className={loading || statusLoading ? 'cu-spin' : undefined}
                width={18}
                height={18}
              />
            </button>
          }
        />
        <div className="cu-discovery-bar">
          {navigation}
          <div className="cu-discovery-status" role="status">
            <span>
              {status
                ? `Last synced ${formatRunAt(status.ranAt)}`
                : 'Not synced yet. Run a sync to pull the latest catalog.'}
            </span>
            {status ? (
              <span className="cu-discovery-status__facts">
                <span
                  className={`cu-px-badge ${
                    status.source === 'live' ? 'cu-px-badge--info' : 'cu-px-badge--warn'
                  }`}
                >
                  {status.source === 'live' ? 'Live catalog' : 'Vendored fallback'}
                </span>
                <span>+{status.added} new</span>
                <span>{status.updated} refreshed</span>
                <span>{status.staled} stale</span>
              </span>
            ) : null}
          </div>
        </div>

        <TableViewport className="cu-table-wrap cu-table-wrap--sticky-header">
          <DataTable
            className="eft-table cu-table cu-table--header-band cu-llm-review-table"
            variant="grouped"
          >
            <thead>
              <TableHeaderRow columns={providerColumns} />
            </thead>
            {isInitialLoad ? (
              <tbody>
                <TableStateRow
                  colSpan={providerColumns.length}
                  kind="loading"
                  message="Loading discovery review…"
                />
              </tbody>
            ) : reviewQueue.length === 0 ? (
              <tbody>
                <TableStateRow
                  colSpan={providerColumns.length}
                  message="No models awaiting review. Sync the catalog to pull newly released models."
                />
              </tbody>
            ) : (
              groupedReviewRows.map(([provider, models]) => {
                const providerLabel = getProviderDisplayLabel(provider)
                const expanded = expandedProviders.has(provider)

                return (
                  <GroupedTableBody
                    childBodyClassName="cu-llm-model-group__children"
                    childHeader={<TableHeaderRow columns={reviewColumns} />}
                    childTableClassName="cu-llm-review-table__children"
                    className="cu-llm-model-group"
                    colSpan={providerColumns.length}
                    disclosureClassName="cu-llm-model-group__toggle"
                    disclosureLabel={isExpanded =>
                      `${isExpanded ? 'Collapse' : 'Expand'} ${providerLabel} review models`
                    }
                    expanded={expanded}
                    groupId={provider}
                    key={provider}
                    nestedChildTable
                    onExpandedChange={nextExpanded => setProviderExpanded(provider, nextExpanded)}
                    summaryCells={[
                      {
                        key: 'provider',
                        content: (
                          <>
                            <LlmProviderIcon provider={provider} label={providerLabel} />
                            <span className="cu-llm-model-group__provider">{providerLabel}</span>
                          </>
                        ),
                      },
                      {
                        key: 'models',
                        content: (
                          <span className="cu-llm-model-group__count">
                            {models.length} model{models.length === 1 ? '' : 's'}
                          </span>
                        ),
                      },
                      {
                        key: 'details',
                        content: (
                          <span className="cu-llm-model-group__summary">Awaiting review</span>
                        ),
                      },
                      {
                        key: 'actions',
                        className: 'cu-llm-model-group__action-cell',
                        content: (
                          <span className="cu-llm-model-group__action" aria-hidden="true">
                            {expanded ? 'Hide models' : 'Show models'}
                          </span>
                        ),
                      },
                    ]}
                  >
                    {models.map(model => (
                      <tr key={model.id} className="cu-table__row cu-llm-model-row">
                        <td>
                          <input
                            type="checkbox"
                            checked={selectedIds.has(model.id)}
                            onChange={() => toggleRow(model.id)}
                            disabled={bulkEnabling}
                            aria-label={`Select ${modelLabel(model)}`}
                          />
                        </td>
                        <td className="cu-px-model">{model.model}</td>
                        <td>{model.vendor || '—'}</td>
                        <td className="cu-px-num">
                          {formatContextWindow(model.context_window_tokens)}
                        </td>
                        <td className="cu-px-actions">
                          <button
                            type="button"
                            className="cu-btn cu-btn--primary cu-btn--sm"
                            onClick={() => setEnableConfirmation({ kind: 'single', model })}
                            disabled={pendingId === model.id || bulkEnabling}
                          >
                            {pendingId === model.id ? 'Enabling…' : 'Enable'}
                          </button>
                        </td>
                      </tr>
                    ))}
                  </GroupedTableBody>
                )
              })
            )}
          </DataTable>
        </TableViewport>
      </div>
      <ConfirmationDialog
        open={enableConfirmation !== null}
        onCancel={() => setEnableConfirmation(null)}
        onConfirm={confirmEnable}
        title={
          enableConfirmation?.kind === 'single'
            ? `Enable ${modelLabel(enableConfirmation.model)}?`
            : `Enable ${selectedCount} selected models?`
        }
        description={
          enableConfirmation?.kind === 'single'
            ? 'This model will become available to agents and runtime.'
            : `This will enable ${selectedCount} models. Each model is updated independently.`
        }
        confirmLabel={
          enableConfirmation?.kind === 'single'
            ? `Enable ${modelLabel(enableConfirmation.model)}`
            : `Enable ${selectedCount} models`
        }
        pending={pendingId !== null || bulkEnabling}
      />
    </>
  )
}