Skip to content

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

5.0 KB
Raw Blame
'use client';

import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';

import { CanCreateAgentProvider } from '../hooks/useCanCreateAgent.js';
import type {
  AgentBuilderCapabilitiesResponse,
  AgentMetricsServer,
  AgentSessionsServer,
  AgentUIServer,
  CatalogServer,
  PermissionsServer,
  SandboxEnvironmentServer,
  ScheduleServer,
} from './types.js';

const ServerContext = createContext<AgentUIServer | null>(null);
const ServerCapabilitiesContext = createContext<{
  capabilities: AgentBuilderCapabilitiesResponse['data'] | null;
  settled: boolean;
  refresh: () => void;
} | null>(null);

export function ServerProvider({ server, children }: { server: AgentUIServer; children: ReactNode }) {
  const [capabilities, setCapabilities] = useState<AgentBuilderCapabilitiesResponse['data'] | null>(null);
  const [capabilitiesSettled, setCapabilitiesSettled] = useState(false);
  const cancelActiveRequestRef = useRef<(() => void) | null>(null);
  const refreshCapabilities = useCallback(() => {
    cancelActiveRequestRef.current?.();
    let cancelled = false;
    cancelActiveRequestRef.current = () => {
      cancelled = true;
    };
    void server
      .getCapabilities()
      .then(response => {
        if (!cancelled) setCapabilities(response.data);
      })
      .catch(() => {
        // Preserve the last known capabilities when a refresh fails.
      })
      .finally(() => {
        if (!cancelled) setCapabilitiesSettled(true);
      });
  }, [server]);

  useEffect(() => {
    setCapabilities(null);
    setCapabilitiesSettled(false);
    refreshCapabilities();
    return () => {
      cancelActiveRequestRef.current?.();
    };
  }, [refreshCapabilities]);

  const capabilitiesValue = useMemo(
    () => ({ capabilities, settled: capabilitiesSettled, refresh: refreshCapabilities }),
    [capabilities, capabilitiesSettled, refreshCapabilities],
  );

  return (
    <ServerContext.Provider value={server}>
      <ServerCapabilitiesContext.Provider value={capabilitiesValue}>
        <CanCreateAgentProvider permissionsServer={server.permissions ?? null}>{children}</CanCreateAgentProvider>
      </ServerCapabilitiesContext.Provider>
    </ServerContext.Provider>
  );
}

export function useServer(): AgentUIServer {
  const server = useContext(ServerContext);
  if (server == null) {
    throw new Error('useServer must be used within a ServerProvider.');
  }
  return server;
}

export function useOptionalServer(): AgentUIServer | null {
  return useContext(ServerContext);
}

export function useServerCapabilities(): AgentBuilderCapabilitiesResponse['data'] | null {
  return useContext(ServerCapabilitiesContext)?.capabilities ?? null;
}

export function useServerCapabilitiesSettled(): boolean {
  return useContext(ServerCapabilitiesContext)?.settled ?? false;
}

export function useOptionalRefreshServerCapabilities(): (() => void) | null {
  return useContext(ServerCapabilitiesContext)?.refresh ?? null;
}

export function useCatalogServer(): CatalogServer {
  const server = useServer();
  if (server.catalog == null) {
    throw new Error('useCatalogServer requires AgentUIServer.catalog. Pass catalog to createTrueForgeServer.');
  }
  return server.catalog;
}

export function useOptionalCatalogServer(): CatalogServer | null {
  return useOptionalServer()?.catalog ?? null;
}

export function useAgentSessionsServer(): AgentSessionsServer {
  const sessions = useServer().sessions;
  if (sessions == null) {
    throw new Error('useAgentSessionsServer requires AgentUIServer.sessions.');
  }
  return sessions;
}

export function useOptionalAgentSessionsServer(): AgentSessionsServer | null {
  return useOptionalServer()?.sessions ?? null;
}

export function useAgentMetricsServer(): AgentMetricsServer {
  const metrics = useServer().metrics;
  if (metrics == null) {
    throw new Error('useAgentMetricsServer requires AgentUIServer.metrics.');
  }
  return metrics;
}

export function useOptionalAgentMetricsServer(): AgentMetricsServer | null {
  return useOptionalServer()?.metrics ?? null;
}

export function useScheduleServer(): ScheduleServer {
  const server = useServer();
  if (server.schedules == null) {
    throw new Error('useScheduleServer requires AgentUIServer.schedules. Pass schedules to createTrueForgeServer.');
  }
  return server.schedules;
}

export function useOptionalScheduleServer(): ScheduleServer | null {
  return useOptionalServer()?.schedules ?? null;
}

export function useSandboxEnvironmentServer(): SandboxEnvironmentServer {
  const server = useServer();
  if (server.sandboxEnvironments == null) {
    throw new Error(
      'useSandboxEnvironmentServer requires AgentUIServer.sandboxEnvironments. Pass sandboxEnvironments to createTrueForgeServer.',
    );
  }
  return server.sandboxEnvironments;
}

export function useOptionalSandboxEnvironmentServer(): SandboxEnvironmentServer | null {
  return useOptionalServer()?.sandboxEnvironments ?? null;
}

export function useOptionalPermissionsServer(): PermissionsServer | null {
  return useOptionalServer()?.permissions ?? null;
}