Skip to content

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

TypeScript
6.9 KB
Raw Blame
import { useEffect, useMemo, useState } from 'react'
import type { TaskProgress } from '../../uiTypes'
import { useChatStore } from '../useChatStore'
import type { SidebarChatEntry } from './useAgentChatController'

interface UseActivityControllerParams {
  selectedAgent: string | null
  isAuthenticated: boolean
  loadMenuData: boolean
  chatList: SidebarChatEntry[]
  progressByAgentMessage: Record<string, Record<string, TaskProgress>>
  agentNames: string[]
}

const ACTIVITY_SUMMARY_CHAT_SCAN_LIMIT = 20
const ACTIVITY_SUMMARY_MESSAGE_SCAN_LIMIT = 1000

function sortableActivityTimestamp(value: string): number {
  const timestamp = Date.parse(value)
  return Number.isFinite(timestamp) ? timestamp : 0
}

function activityCounterKey(agentRef: string, chatId: string): string {
  return `${agentRef}\u0000${chatId}`
}

export function useActivityController({
  selectedAgent,
  isAuthenticated,
  loadMenuData,
  chatList,
  progressByAgentMessage,
  agentNames,
}: UseActivityControllerParams) {
  const chatStore = useChatStore()

  const [agentLastActiveByAgent, setAgentLastActiveByAgent] = useState<
    Record<string, string | null>
  >({})
  const [backfilledCountersByChat, setBackfilledCountersByChat] = useState<
    Record<string, { errors: number; toolCalls: number }>
  >({})
  const selectedAgentActivitySummary = useMemo(() => {
    if (!selectedAgent) {
      return {
        conversations: 0,
        messages: 0,
        toolCalls: 0,
        errors: 0,
        conversationsPerDay: [] as Array<{ dayLabel: string; count: number }>,
      }
    }

    const dateCursor = new Date()
    const dayKeys: string[] = []
    for (let index = 6; index >= 0; index -= 1) {
      const day = new Date(dateCursor)
      day.setDate(day.getDate() - index)
      dayKeys.push(day.toISOString().slice(0, 10))
    }

    const conversationsPerDayMap = new Map<string, number>(dayKeys.map(key => [key, 0]))
    let totalMessages = 0
    let totalErrors = 0
    let persistedToolCalls = 0

    for (const chat of chatList) {
      const backfilledCounters =
        backfilledCountersByChat[activityCounterKey(selectedAgent, chat.id)]
      totalMessages += chat.messageCount || 0
      totalErrors += chat.errorCount ?? backfilledCounters?.errors ?? 0
      persistedToolCalls += chat.toolCallCount ?? backfilledCounters?.toolCalls ?? 0

      const chatTimestamp = Date.parse(chat.updatedAt)
      if (Number.isNaN(chatTimestamp)) continue
      const chatDateKey = new Date(chatTimestamp).toISOString().slice(0, 10)
      if (conversationsPerDayMap.has(chatDateKey)) {
        conversationsPerDayMap.set(chatDateKey, (conversationsPerDayMap.get(chatDateKey) || 0) + 1)
      }
    }

    const liveToolCalls = Object.values(progressByAgentMessage[selectedAgent] || {}).reduce(
      (total, progress) => total + progress.steps.length,
      0
    )
    const formatter = new Intl.DateTimeFormat(undefined, { month: 'short', day: 'numeric' })

    return {
      conversations: chatList.length,
      messages: totalMessages,
      toolCalls: Math.max(persistedToolCalls, liveToolCalls),
      errors: totalErrors,
      conversationsPerDay: [...conversationsPerDayMap.entries()].map(([dayKey, count]) => ({
        dayLabel: formatter.format(new Date(dayKey)),
        count,
      })),
    }
  }, [backfilledCountersByChat, chatList, progressByAgentMessage, selectedAgent])

  const missingCounterChatIds = JSON.stringify(
    chatList
      .filter(chat => {
        const key = selectedAgent ? activityCounterKey(selectedAgent, chat.id) : ''
        return (
          !chat.remote &&
          backfilledCountersByChat[key] === undefined &&
          (chat.errorCount === undefined || chat.toolCallCount === undefined)
        )
      })
      .sort(
        (left, right) =>
          sortableActivityTimestamp(right.updatedAt) - sortableActivityTimestamp(left.updatedAt)
      )
      .slice(0, ACTIVITY_SUMMARY_CHAT_SCAN_LIMIT)
      .map(chat => chat.id)
  )

  useEffect(() => {
    if (!isAuthenticated || !loadMenuData || !selectedAgent) {
      setBackfilledCountersByChat({})
      return
    }
    const chatIds = JSON.parse(missingCounterChatIds) as string[]
    if (!chatIds.length) return

    let cancelled = false
    void Promise.all(
      chatIds.map(async chatId => {
        let messages: Awaited<ReturnType<typeof chatStore.loadMessages>>
        try {
          messages = await chatStore.loadMessages(
            selectedAgent,
            chatId,
            ACTIVITY_SUMMARY_MESSAGE_SCAN_LIMIT
          )
        } catch {
          // A failed read is unknown, not an empty transcript. Leave this chat
          // unmarked so a later catalog refresh can retry the backfill.
          return null
        }
        try {
          await chatStore.backfillCounters(selectedAgent, chatId, messages)
        } catch {
          // Older preload bridges cannot persist the backfill; keep the computed
          // renderer value for this session and retry after the app upgrades.
        }
        return [
          activityCounterKey(selectedAgent, chatId),
          {
            errors: messages.reduce((total, message) => total + (message.isError ? 1 : 0), 0),
            toolCalls: messages.reduce(
              (total, message) => total + (message.toolSteps?.length ?? 0),
              0
            ),
          },
        ] as const
      })
    ).then(entries => {
      if (!cancelled) {
        const successfulEntries = entries.filter(entry => entry !== null)
        setBackfilledCountersByChat(previous => ({
          ...previous,
          ...Object.fromEntries(successfulEntries),
        }))
      }
    })

    return () => {
      cancelled = true
    }
  }, [
    chatStore.backfillCounters,
    chatStore.loadMessages,
    isAuthenticated,
    loadMenuData,
    missingCounterChatIds,
    selectedAgent,
  ])

  // Compute agentLastActiveByAgent for all agents
  useEffect(() => {
    if (!isAuthenticated || !loadMenuData || !agentNames.length) {
      setAgentLastActiveByAgent({})
      return
    }

    let cancelled = false
    ;(async () => {
      const entries = await Promise.all(
        agentNames.map(async agentName => {
          try {
            const index = await chatStore.getIndex(agentName)
            const latestUpdatedAt = (index.chats || [])
              .map((chat: { updatedAt: string }) => chat.updatedAt)
              .filter(
                (updatedAt: string) => typeof updatedAt === 'string' && updatedAt.trim().length > 0
              )
              .sort((a: string, b: string) => Date.parse(b) - Date.parse(a))[0]
            return [agentName, latestUpdatedAt || null] as const
          } catch {
            return [agentName, null] as const
          }
        })
      )
      if (!cancelled) {
        setAgentLastActiveByAgent(Object.fromEntries(entries))
      }
    })()

    return () => {
      cancelled = true
    }
  }, [agentNames, chatStore.getIndex, isAuthenticated, loadMenuData])

  return {
    agentLastActiveByAgent,
    selectedAgentActivitySummary,
  }
}