Skip to content

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

chore: refetch capabilities on new chat click (#126)

sayan-truefoundryc00dfbefb519
diff --git a/packages/trueforge-ui-sdk/src/server/ServerContext.tsx b/packages/trueforge-ui-sdk/src/server/ServerContext.tsx
index d3c76a936..cf643ba85 100644
--- a/packages/trueforge-ui-sdk/src/server/ServerContext.tsx
+++ b/packages/trueforge-ui-sdk/src/server/ServerContext.tsx
@@ -1,34 +1,50 @@
'use client';
-import { createContext, useContext, useEffect, useState, type ReactNode } from 'react';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
import type { AgentBuilderCapabilitiesResponse, AgentUIServer, CatalogServer } from './types.js';
const ServerContext = createContext<AgentUIServer | null>(null);
-const ServerCapabilitiesContext = createContext<AgentBuilderCapabilitiesResponse['data'] | null>(null);
+const ServerCapabilitiesContext = createContext<{
+ capabilities: AgentBuilderCapabilitiesResponse['data'] | null;
+ refresh: () => void;
+} | null>(null);
export function ServerProvider({ server, children }: { server: AgentUIServer; children: ReactNode }) {
const [capabilities, setCapabilities] = useState<AgentBuilderCapabilitiesResponse['data'] | null>(null);
+ 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.
+ });
+ }, [server]);
useEffect(() => {
- let cancelled = false;
setCapabilities(null);
- void server.getCapabilities().then(
- response => {
- if (!cancelled) setCapabilities(response.data);
- },
- () => {
- if (!cancelled) setCapabilities(null);
- },
- );
+ refreshCapabilities();
return () => {
- cancelled = true;
+ cancelActiveRequestRef.current?.();
};
- }, [server]);
+ }, [refreshCapabilities]);
+
+ const capabilitiesValue = useMemo(
+ () => ({ capabilities, refresh: refreshCapabilities }),
+ [capabilities, refreshCapabilities],
+ );
return (
<ServerContext.Provider value={server}>
- <ServerCapabilitiesContext.Provider value={capabilities}>{children}</ServerCapabilitiesContext.Provider>
+ <ServerCapabilitiesContext.Provider value={capabilitiesValue}>{children}</ServerCapabilitiesContext.Provider>
</ServerContext.Provider>
);
}
@@ -46,7 +62,11 @@ export function useOptionalServer(): AgentUIServer | null {
}
export function useServerCapabilities(): AgentBuilderCapabilitiesResponse['data'] | null {
- return useContext(ServerCapabilitiesContext);
+ return useContext(ServerCapabilitiesContext)?.capabilities ?? null;
+}
+
+export function useOptionalRefreshServerCapabilities(): (() => void) | null {
+ return useContext(ServerCapabilitiesContext)?.refresh ?? null;
}
export function useCatalogServer(): CatalogServer {
diff --git a/packages/trueforge-ui-sdk/src/server/ShellModeContext.tsx b/packages/trueforge-ui-sdk/src/server/ShellModeContext.tsx
index 0b0d39726..812d6d953 100644
--- a/packages/trueforge-ui-sdk/src/server/ShellModeContext.tsx
+++ b/packages/trueforge-ui-sdk/src/server/ShellModeContext.tsx
@@ -2,7 +2,7 @@
import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
-import { useServerCapabilities } from './ServerContext.js';
+import { useOptionalRefreshServerCapabilities, useServerCapabilities } from './ServerContext.js';
import type { AgentLibraryEntry, AgentSpec } from './types.js';
/** Host-facing shell configuration for agent / library / composer chrome. */
@@ -148,6 +148,7 @@ export function ShellModeProvider({
children: ReactNode;
}) {
const capabilities = useServerCapabilities();
+ const refreshCapabilities = useOptionalRefreshServerCapabilities();
const mutableSeedRef = useRef(mutableSeedFromConfig(agentConfig));
if (
(agentConfig.mode === 'AgentComposer' || agentConfig.mode === 'AgentLibraryWithComposer') &&
@@ -271,8 +272,10 @@ export function ShellModeProvider({
);
const openDraft = useCallback(() => {
+ if (!isComposerEnabled) return;
+ refreshCapabilities?.();
selectLibraryAgent({ isMutable: true, agentSpec: mutableSeedRef.current });
- }, [selectLibraryAgent]);
+ }, [isComposerEnabled, refreshCapabilities, selectLibraryAgent]);
const openHistorySession = useCallback(
({
diff --git a/packages/trueforge-ui-sdk/test/containers/TrueforgeUI.test.tsx b/packages/trueforge-ui-sdk/test/containers/TrueforgeUI.test.tsx
index 94a3a4d67..87d03456f 100644
--- a/packages/trueforge-ui-sdk/test/containers/TrueforgeUI.test.tsx
+++ b/packages/trueforge-ui-sdk/test/containers/TrueforgeUI.test.tsx
@@ -113,6 +113,49 @@ describe('TrueforgeUI', () => {
});
});
+ it('refetches composer data when starting a new chat', async () => {
+ const getCapabilities = vi
+ .fn()
+ .mockResolvedValueOnce({ data: { sandbox: { enabled: true }, skill: { enabled: true } } })
+ .mockResolvedValueOnce({
+ data: {
+ sandbox: { enabled: false },
+ skill: { enabled: false, reason: 'Select Sandbox first' },
+ },
+ });
+ const getModels = vi.fn(async () => []);
+ const getSkills = vi.fn(async () => []);
+ const getMcp = vi.fn(async () => []);
+
+ render(
+ <TrueforgeUI
+ server={createMockAgentUIServer({ getCapabilities, getModels, getSkills, getMcp })}
+ agentConfig={{ mode: 'AgentComposer' }}
+ layout="sidebar"
+ />,
+ );
+
+ await waitFor(() => {
+ expect(getCapabilities).toHaveBeenCalledTimes(1);
+ expect(getModels).toHaveBeenCalledTimes(1);
+ expect(getSkills).toHaveBeenCalledTimes(1);
+ expect(getMcp).toHaveBeenCalledTimes(1);
+ });
+
+ fireEvent.click(screen.getByRole('button', { name: 'Start new chat' }));
+
+ await waitFor(() => {
+ expect(getCapabilities).toHaveBeenCalledTimes(2);
+ expect(getModels).toHaveBeenCalledTimes(2);
+ expect(getSkills).toHaveBeenCalledTimes(2);
+ expect(getMcp).toHaveBeenCalledTimes(2);
+ });
+
+ fireEvent.click(screen.getByRole('button', { name: 'Add connectors, skills, or attachments' }));
+ fireEvent.click(screen.getByRole('button', { name: /Skills/ }));
+ expect(await screen.findByRole('status')).toHaveTextContent('Select Sandbox first');
+ });
+
it('renders only the MCP authorization screen when requested by the URL', async () => {
const originalUrl = window.location.href;
const postMessage = vi.fn();
diff --git a/packages/trueforge-ui-sdk/test/server/ServerContext.test.tsx b/packages/trueforge-ui-sdk/test/server/ServerContext.test.tsx
index 8ada6ffc5..a12c7f849 100644
--- a/packages/trueforge-ui-sdk/test/server/ServerContext.test.tsx
+++ b/packages/trueforge-ui-sdk/test/server/ServerContext.test.tsx
@@ -1,5 +1,5 @@
// @vitest-environment jsdom
-import { renderHook } from '@testing-library/react';
+import { act, renderHook, waitFor } from '@testing-library/react';
import type { ReactNode } from 'react';
import { describe, expect, it, vi } from 'vitest';
@@ -7,8 +7,10 @@ import {
ServerProvider,
useCatalogServer,
useOptionalCatalogServer,
+ useOptionalRefreshServerCapabilities,
useOptionalServer,
useServer,
+ useServerCapabilities,
} from '@/server/ServerContext.js';
import type { AgentUIServer, CatalogServer } from '@/server/types.js';
import { createMockAgentUIServer } from './mockServer.js';
@@ -115,6 +117,28 @@ describe('ServerProvider', () => {
expect(result.current).toBeNull();
});
+
+ it('retains existing capabilities when a refresh fails', async () => {
+ const initialCapabilities = { sandbox: { enabled: true }, skill: { enabled: true } };
+ const getCapabilities = vi
+ .fn()
+ .mockResolvedValueOnce({ data: initialCapabilities })
+ .mockRejectedValueOnce(new Error('Unavailable'));
+ const server = createMockAgentUIServer({ getCapabilities });
+ const { result } = renderHook(
+ () => ({
+ capabilities: useServerCapabilities(),
+ refresh: useOptionalRefreshServerCapabilities(),
+ }),
+ { wrapper: wrap(server) },
+ );
+
+ await waitFor(() => expect(result.current.capabilities).toEqual(initialCapabilities));
+ act(() => result.current.refresh?.());
+ await waitFor(() => expect(getCapabilities).toHaveBeenCalledTimes(2));
+
+ expect(result.current.capabilities).toEqual(initialCapabilities);
+ });
});
describe('useCatalogServer', () => {