Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

📋 refactor: Agent Tool Permissions for File Upload Options (#9647)

Danny Avila673836005182
diff --git a/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.tsx b/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.tsx
new file mode 100644
index 0000000000..604ffef8de
--- /dev/null
+++ b/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.tsx
@@ -0,0 +1,440 @@
+import { renderHook } from '@testing-library/react';
+import { Tools, Constants } from 'librechat-data-provider';
+import useAgentToolPermissions from '../useAgentToolPermissions';
+
+// Mock dependencies
+jest.mock('~/data-provider', () => ({
+ useGetAgentByIdQuery: jest.fn(),
+}));
+
+jest.mock('~/Providers', () => ({
+ useAgentsMapContext: jest.fn(),
+}));
+
+// Import mocked functions after mocking
+import { useGetAgentByIdQuery } from '~/data-provider';
+import { useAgentsMapContext } from '~/Providers';
+
+describe('useAgentToolPermissions', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('Ephemeral Agent Scenarios', () => {
+ it('should return true for all tools when agentId is null', () => {
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(null));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should return true for all tools when agentId is undefined', () => {
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(undefined));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should return true for all tools when agentId is empty string', () => {
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(''));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should return true for all tools when agentId is EPHEMERAL_AGENT_ID', () => {
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() =>
+ useAgentToolPermissions(Constants.EPHEMERAL_AGENT_ID)
+ );
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toBeUndefined();
+ });
+ });
+
+ describe('Regular Agent with Tools', () => {
+ it('should allow file_search when agent has the tool', () => {
+ const agentId = 'agent-123';
+ const mockAgent = {
+ id: agentId,
+ tools: [Tools.file_search, 'other_tool'],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toEqual([Tools.file_search, 'other_tool']);
+ });
+
+ it('should allow execute_code when agent has the tool', () => {
+ const agentId = 'agent-456';
+ const mockAgent = {
+ id: agentId,
+ tools: [Tools.execute_code, 'another_tool'],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toEqual([Tools.execute_code, 'another_tool']);
+ });
+
+ it('should allow both tools when agent has both', () => {
+ const agentId = 'agent-789';
+ const mockAgent = {
+ id: agentId,
+ tools: [Tools.file_search, Tools.execute_code, 'custom_tool'],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toEqual([Tools.file_search, Tools.execute_code, 'custom_tool']);
+ });
+
+ it('should disallow both tools when agent has neither', () => {
+ const agentId = 'agent-no-tools';
+ const mockAgent = {
+ id: agentId,
+ tools: ['custom_tool1', 'custom_tool2'],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toEqual(['custom_tool1', 'custom_tool2']);
+ });
+
+ it('should handle agent with empty tools array', () => {
+ const agentId = 'agent-empty-tools';
+ const mockAgent = {
+ id: agentId,
+ tools: [],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toEqual([]);
+ });
+
+ it('should handle agent with undefined tools', () => {
+ const agentId = 'agent-undefined-tools';
+ const mockAgent = {
+ id: agentId,
+ tools: undefined,
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+ });
+
+ describe('Agent Data from Query', () => {
+ it('should prioritize agentData tools over selectedAgent tools', () => {
+ const agentId = 'agent-with-query-data';
+ const mockAgent = {
+ id: agentId,
+ tools: ['old_tool'],
+ };
+ const mockAgentData = {
+ id: agentId,
+ tools: [Tools.file_search, Tools.execute_code],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: mockAgentData });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ expect(result.current.tools).toEqual([Tools.file_search, Tools.execute_code]);
+ });
+
+ it('should fallback to selectedAgent tools when agentData has no tools', () => {
+ const agentId = 'agent-fallback';
+ const mockAgent = {
+ id: agentId,
+ tools: [Tools.file_search],
+ };
+ const mockAgentData = {
+ id: agentId,
+ tools: undefined,
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: mockAgentData });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toEqual([Tools.file_search]);
+ });
+ });
+
+ describe('Agent Not Found Scenarios', () => {
+ it('should disallow all tools when agent is not found in map', () => {
+ const agentId = 'non-existent-agent';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should disallow all tools when agentsMap is null', () => {
+ const agentId = 'agent-with-null-map';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue(null);
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should disallow all tools when agentsMap is undefined', () => {
+ const agentId = 'agent-with-undefined-map';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue(undefined);
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+ });
+
+ describe('Memoization and Performance', () => {
+ it('should memoize results when inputs do not change', () => {
+ const agentId = 'memoized-agent';
+ const mockAgent = {
+ id: agentId,
+ tools: [Tools.file_search],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result, rerender } = renderHook(() => useAgentToolPermissions(agentId));
+
+ const firstResult = result.current;
+
+ // Rerender without changing inputs
+ rerender();
+
+ const secondResult = result.current;
+
+ // The hook returns a new object each time, but the values should be equal
+ expect(firstResult.fileSearchAllowedByAgent).toBe(secondResult.fileSearchAllowedByAgent);
+ expect(firstResult.codeAllowedByAgent).toBe(secondResult.codeAllowedByAgent);
+ // Tools array reference should be the same since it comes from useMemo
+ expect(firstResult.tools).toBe(secondResult.tools);
+
+ // Verify the actual values are correct
+ expect(secondResult.fileSearchAllowedByAgent).toBe(true);
+ expect(secondResult.codeAllowedByAgent).toBe(false);
+ expect(secondResult.tools).toEqual([Tools.file_search]);
+ });
+
+ it('should recompute when agentId changes', () => {
+ const agentId1 = 'agent-1';
+ const agentId2 = 'agent-2';
+ const mockAgents = {
+ [agentId1]: { id: agentId1, tools: [Tools.file_search] },
+ [agentId2]: { id: agentId2, tools: [Tools.execute_code] },
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue(mockAgents);
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result, rerender } = renderHook(
+ ({ agentId }) => useAgentToolPermissions(agentId),
+ { initialProps: { agentId: agentId1 } }
+ );
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+
+ // Change agentId
+ rerender({ agentId: agentId2 });
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ });
+
+ it('should handle switching between ephemeral and regular agents', () => {
+ const regularAgentId = 'regular-agent';
+ const mockAgent = {
+ id: regularAgentId,
+ tools: [],
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [regularAgentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result, rerender } = renderHook(
+ ({ agentId }) => useAgentToolPermissions(agentId),
+ { initialProps: { agentId: null } }
+ );
+
+ // Start with ephemeral agent (null)
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+
+ // Switch to regular agent
+ rerender({ agentId: regularAgentId });
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+
+ // Switch back to ephemeral
+ rerender({ agentId: '' });
+ expect(result.current.fileSearchAllowedByAgent).toBe(true);
+ expect(result.current.codeAllowedByAgent).toBe(true);
+ });
+ });
+
+ describe('Edge Cases', () => {
+ it('should handle agents with null tools gracefully', () => {
+ const agentId = 'agent-null-tools';
+ const mockAgent = {
+ id: agentId,
+ tools: null as any,
+ };
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({
+ [agentId]: mockAgent,
+ });
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeNull();
+ });
+
+ it('should handle whitespace-only agentId as ephemeral', () => {
+ // Note: Based on the current implementation, only empty string is treated as ephemeral
+ // Whitespace-only strings would be treated as regular agent IDs
+ const whitespaceId = ' ';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({ data: undefined });
+
+ const { result } = renderHook(() => useAgentToolPermissions(whitespaceId));
+
+ // Whitespace ID is not considered ephemeral in current implementation
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ });
+
+ it('should handle query loading state', () => {
+ const agentId = 'loading-agent';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({
+ data: undefined,
+ isLoading: true,
+ error: null,
+ });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ // During loading, should return false for non-ephemeral agents
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+
+ it('should handle query error state', () => {
+ const agentId = 'error-agent';
+
+ (useAgentsMapContext as jest.Mock).mockReturnValue({});
+ (useGetAgentByIdQuery as jest.Mock).mockReturnValue({
+ data: undefined,
+ isLoading: false,
+ error: new Error('Failed to fetch agent'),
+ });
+
+ const { result } = renderHook(() => useAgentToolPermissions(agentId));
+
+ // On error, should return false for non-ephemeral agents
+ expect(result.current.fileSearchAllowedByAgent).toBe(false);
+ expect(result.current.codeAllowedByAgent).toBe(false);
+ expect(result.current.tools).toBeUndefined();
+ });
+ });
+});
diff --git a/client/src/hooks/Agents/useAgentToolPermissions.ts b/client/src/hooks/Agents/useAgentToolPermissions.ts
index da27492f3a..c0b0699f91 100644
--- a/client/src/hooks/Agents/useAgentToolPermissions.ts
+++ b/client/src/hooks/Agents/useAgentToolPermissions.ts
@@ -1,5 +1,5 @@
import { useMemo } from 'react';
-import { Tools } from 'librechat-data-provider';
+import { Tools, Constants } from 'librechat-data-provider';
import { useGetAgentByIdQuery } from '~/data-provider';
import { useAgentsMapContext } from '~/Providers';
@@ -9,6 +9,10 @@ interface AgentToolPermissionsResult {
tools: string[] | undefined;
}
+function isEphemeralAgent(agentId: string | null | undefined): boolean {
+ return agentId == null || agentId === '' || agentId === Constants.EPHEMERAL_AGENT_ID;
+}
+
/**
* Hook to determine whether specific tools are allowed for a given agent.
*
@@ -33,8 +37,8 @@ export default function useAgentToolPermissions(
);
const fileSearchAllowedByAgent = useMemo(() => {
- // If no agentId, allow for ephemeral agents
- if (!agentId) return true;
+ // Allow for ephemeral agents
+ if (isEphemeralAgent(agentId)) return true;
// If agentId exists but agent not found, disallow
if (!selectedAgent) return false;
// Check if the agent has the file_search tool
@@ -42,8 +46,8 @@ export default function useAgentToolPermissions(
}, [agentId, selectedAgent, tools]);
const codeAllowedByAgent = useMemo(() => {
- // If no agentId, allow for ephemeral agents
- if (!agentId) return true;
+ // Allow for ephemeral agents
+ if (isEphemeralAgent(agentId)) return true;
// If agentId exists but agent not found, disallow
if (!selectedAgent) return false;
// Check if the agent has the execute_code tool