The open-source agent harness - the runtime layer that turns an LLM into a working agent.
'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;
}