Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

3.8 KB
Raw Blame
'use client';

import { useEffect, useState, type ComponentType } from 'react';

import type { AgentMetricChartResult, AgentMetricsProps } from '../atoms/agent-details/types.js';
import { useAgentMetricsServer } from '../server/ServerContext.js';
import type { AgentMetricChartDefinition, AgentMetricMeter } from '../server/types.js';
import { useSlot } from '../theme/SlotsProvider.js';
import { getErrorMessage } from '../utils/getErrorMessage.js';
import { defaultMetricsTimeRange, resolveSessionTimeRange } from '../utils/sessionShareUrl.js';

export function AgentMetricsContainer({
  agentId,
  timeRange: controlledTimeRange,
  onTimeRangeChange,
  showTimeRangeFilter = true,
}: AgentMetricsProps) {
  const metricsServer = useAgentMetricsServer();
  const AgentMetricsView = useSlot('AgentMetricsView');
  const [internalTimeRange, setInternalTimeRange] = useState(defaultMetricsTimeRange);
  const timeRange = controlledTimeRange ?? internalTimeRange;
  const setTimeRange = onTimeRangeChange ?? setInternalTimeRange;
  const [definitions, setDefinitions] = useState<AgentMetricChartDefinition[]>();
  const [chartsError, setChartsError] = useState<string>();
  const [meters, setMeters] = useState<AgentMetricMeter[]>();
  const [meterError, setMeterError] = useState<string>();
  const [charts, setCharts] = useState<AgentMetricChartResult[]>([]);
  const [chartsLoading, setChartsLoading] = useState(true);

  useEffect(() => {
    let cancelled = false;
    setDefinitions(undefined);
    setChartsError(undefined);
    void metricsServer.getCharts().then(
      result => {
        if (!cancelled) setDefinitions(result);
      },
      error => {
        if (!cancelled) {
          setDefinitions([]);
          setChartsError(getErrorMessage(error, 'Metric charts could not be loaded.'));
          setChartsLoading(false);
        }
      },
    );
    return () => {
      cancelled = true;
    };
  }, [metricsServer]);

  useEffect(() => {
    if (definitions == null) return undefined;
    let cancelled = false;
    const resolvedRange = resolveSessionTimeRange(timeRange);
    const request = {
      agentId,
      startTimestamp: new Date(resolvedRange.startTs).toISOString(),
      endTimestamp: new Date(resolvedRange.endTs).toISOString(),
    };

    setMeters(undefined);
    setMeterError(undefined);
    setCharts(definitions.map(definition => ({ definition })));
    setChartsLoading(true);

    void metricsServer.getMeters(request).then(
      result => {
        if (!cancelled) setMeters(result);
      },
      error => {
        if (!cancelled) setMeterError(getErrorMessage(error, 'Aggregate metrics could not be loaded.'));
      },
    );

    void Promise.all(
      definitions.map(async definition => {
        try {
          const data = await metricsServer.getChartData({
            ...request,
            chartName: definition.name,
          });
          return { definition, graphs: data.graphs } satisfies AgentMetricChartResult;
        } catch (error) {
          return {
            definition,
            error: getErrorMessage(error, `${definition.displayName} could not be loaded.`),
          } satisfies AgentMetricChartResult;
        }
      }),
    ).then(result => {
      if (!cancelled) {
        setCharts(result);
        setChartsLoading(false);
      }
    });

    return () => {
      cancelled = true;
    };
  }, [agentId, definitions, metricsServer, timeRange]);

  return (
    <AgentMetricsView
      meters={meters}
      meterError={meterError}
      charts={charts}
      chartsLoading={chartsLoading}
      chartsError={chartsError}
      timeRange={timeRange}
      onTimeRangeChange={setTimeRange}
      showTimeRangeFilter={showTimeRangeFilter}
    />
  );
}

declare module '../theme/SlotsProvider.js' {
  interface AtomSlots {
    AgentMetrics: ComponentType<AgentMetricsProps>;
  }
}