refactor: consolidate agent marketplace endpoints into main agents API and improve data management consistency

- Remove dedicated marketplace controller and routes, merging functionality into main agents v1 API - Add countPromotedAgents function to Agent model for promoted agents count - Enhance getListAgents handler with marketplace filtering (category, search, promoted status) - Move getAgentCategories from marketplace to v1 controller with same functionality - Update agent mutations to invalidate marketplace queries and handle multiple permission levels - Improve cache management by updating all agent query variants (VIEW/EDIT permissions) - Consolidate agent data access patterns for better maintainability and consistency - Remove duplicate marketplace route definitions and middleware
2026-02-12 04:24:24 +01:00 · 2025-06-23 10:47:37 +02:00 · 2025-06-23 10:47:37 +02:00 · 6a28d01b20
commit 6a28d01b20
parent 3f6d7ab7c7
14 changed files with 291 additions and 412 deletions
--- a/client/src/components/SidePanel/Agents/AgentAvatar.tsx
+++ b/client/src/components/SidePanel/Agents/AgentAvatar.tsx
@ -14,7 +14,12 @@ import type {
  AgentCreateParams,
  AgentListResponse,
 } from 'librechat-data-provider';
-import { useUploadAgentAvatarMutation, useGetFileConfig } from '~/data-provider';
+import {
+  useUploadAgentAvatarMutation,
+  useGetFileConfig,
+  allAgentViewAndEditQueryKeys,
+  invalidateAgentMarketplaceQueries,
+} from '~/data-provider';
 import { AgentAvatarRender, NoImage, AvatarMenu } from './Images';
 import { useToastContext } from '~/Providers';
 import { useLocalize } from '~/hooks';
@ -57,30 +62,31 @@ function Avatar({
      const newUrl = data.avatar?.filepath ?? '';
      setPreviewUrl(newUrl);

-      const res = queryClient.getQueryData<AgentListResponse>([
-        QueryKeys.agents,
-        defaultOrderQuery,
-      ]);
+      ((keys) => {
+        keys.forEach((key) => {
+          const res = queryClient.getQueryData<AgentListResponse>([QueryKeys.agents, key]);

-      if (!res?.data) {
-        return;
-      }
+          if (!res?.data) {
+            return;
+          }

-      const agents = res.data.map((agent) => {
-        if (agent.id === agent_id) {
-          return {
-            ...agent,
-            ...data,
-          };
-        }
-        return agent;
-      });
-
-      queryClient.setQueryData<AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-        ...res,
-        data: agents,
-      });
+          const agents = res.data.map((agent) => {
+            if (agent.id === agent_id) {
+              return {
+                ...agent,
+                ...data,
+              };
+            }
+            return agent;
+          });

+          queryClient.setQueryData<AgentListResponse>([QueryKeys.agents, key], {
+            ...res,
+            data: agents,
+          });
+        });
+      })(allAgentViewAndEditQueryKeys);
+      invalidateAgentMarketplaceQueries(queryClient);
      setProgress(1);
    },
    onError: (error) => {
--- a/client/src/data-provider/Agents/mutations.ts
+++ b/client/src/data-provider/Agents/mutations.ts
@ -1,12 +1,15 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { dataService, MutationKeys, QueryKeys, defaultOrderQuery } from 'librechat-data-provider';
+import { dataService, MutationKeys, PERMISSION_BITS, QueryKeys } from 'librechat-data-provider';
 import type * as t from 'librechat-data-provider';
-import type { UseMutationResult } from '@tanstack/react-query';
+import type { QueryClient, UseMutationResult } from '@tanstack/react-query';

 /**
 * AGENTS
 */
-
+export const allAgentViewAndEditQueryKeys: t.AgentListParams[] = [
+  { requiredPermission: PERMISSION_BITS.VIEW },
+  { requiredPermission: PERMISSION_BITS.EDIT },
+];
 /**
 * Create a new agent
 */
@ -18,21 +21,22 @@ export const useCreateAgentMutation = (
    onMutate: (variables) => options?.onMutate?.(variables),
    onError: (error, variables, context) => options?.onError?.(error, variables, context),
    onSuccess: (newAgent, variables, context) => {
-      const listRes = queryClient.getQueryData<t.AgentListResponse>([
-        QueryKeys.agents,
-        defaultOrderQuery,
-      ]);
+      ((keys: t.AgentListParams[]) => {
+        keys.forEach((key) => {
+          const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);
+          if (!listRes) {
+            return options?.onSuccess?.(newAgent, variables, context);
+          }
+          const currentAgents = [newAgent, ...JSON.parse(JSON.stringify(listRes.data))];

-      if (!listRes) {
-        return options?.onSuccess?.(newAgent, variables, context);
-      }
+          queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+            ...listRes,
+            data: currentAgents,
+          });
+        });
+      })(allAgentViewAndEditQueryKeys);
+      invalidateAgentMarketplaceQueries(queryClient);

-      const currentAgents = [newAgent, ...JSON.parse(JSON.stringify(listRes.data))];
-
-      queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-        ...listRes,
-        data: currentAgents,
-      });
      return options?.onSuccess?.(newAgent, variables, context);
    },
  });
@ -63,30 +67,33 @@ export const useUpdateAgentMutation = (
        return options?.onError?.(typedError, variables, context);
      },
      onSuccess: (updatedAgent, variables, context) => {
-        const listRes = queryClient.getQueryData<t.AgentListResponse>([
-          QueryKeys.agents,
-          defaultOrderQuery,
-        ]);
+        ((keys: t.AgentListParams[]) => {
+          keys.forEach((key) => {
+            const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);

-        if (!listRes) {
-          return options?.onSuccess?.(updatedAgent, variables, context);
-        }
-
-        queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-          ...listRes,
-          data: listRes.data.map((agent) => {
-            if (agent.id === variables.agent_id) {
-              return updatedAgent;
+            if (!listRes) {
+              return options?.onSuccess?.(updatedAgent, variables, context);
            }
-            return agent;
-          }),
-        });
+
+            queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+              ...listRes,
+              data: listRes.data.map((agent) => {
+                if (agent.id === variables.agent_id) {
+                  return updatedAgent;
+                }
+                return agent;
+              }),
+            });
+          });
+        })(allAgentViewAndEditQueryKeys);

        queryClient.setQueryData<t.Agent>([QueryKeys.agent, variables.agent_id], updatedAgent);
        queryClient.setQueryData<t.Agent>(
          [QueryKeys.agent, variables.agent_id, 'expanded'],
          updatedAgent,
        );
+        invalidateAgentMarketplaceQueries(queryClient);
+
        return options?.onSuccess?.(updatedAgent, variables, context);
      },
    },
@ -108,24 +115,28 @@ export const useDeleteAgentMutation = (
      onMutate: (variables) => options?.onMutate?.(variables),
      onError: (error, variables, context) => options?.onError?.(error, variables, context),
      onSuccess: (_data, variables, context) => {
-        const listRes = queryClient.getQueryData<t.AgentListResponse>([
-          QueryKeys.agents,
-          defaultOrderQuery,
-        ]);
+        const data = ((keys: t.AgentListParams[]) => {
+          let data: t.Agent[] = [];
+          keys.forEach((key) => {
+            const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);

-        if (!listRes) {
-          return options?.onSuccess?.(_data, variables, context);
-        }
+            if (!listRes) {
+              return options?.onSuccess?.(_data, variables, context);
+            }

-        const data = listRes.data.filter((agent) => agent.id !== variables.agent_id);
+            data = listRes.data.filter((agent) => agent.id !== variables.agent_id);

-        queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-          ...listRes,
-          data,
-        });
+            queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+              ...listRes,
+              data,
+            });
+          });
+          return data;
+        })(allAgentViewAndEditQueryKeys);

        queryClient.removeQueries([QueryKeys.agent, variables.agent_id]);
        queryClient.removeQueries([QueryKeys.agent, variables.agent_id, 'expanded']);
+        invalidateAgentMarketplaceQueries(queryClient);

        return options?.onSuccess?.(_data, variables, data);
      },
@ -147,22 +158,23 @@ export const useDuplicateAgentMutation = (
      onMutate: options?.onMutate,
      onError: options?.onError,
      onSuccess: ({ agent, actions }, variables, context) => {
-        const listRes = queryClient.getQueryData<t.AgentListResponse>([
-          QueryKeys.agents,
-          defaultOrderQuery,
-        ]);
-
-        if (listRes) {
-          const currentAgents = [agent, ...listRes.data];
-          queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-            ...listRes,
-            data: currentAgents,
+        ((keys: t.AgentListParams[]) => {
+          keys.forEach((key) => {
+            const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);
+            if (listRes) {
+              const currentAgents = [agent, ...listRes.data];
+              queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+                ...listRes,
+                data: currentAgents,
+              });
+            }
          });
-        }
+        })(allAgentViewAndEditQueryKeys);

        const existingActions = queryClient.getQueryData<t.Action[]>([QueryKeys.actions]) || [];

        queryClient.setQueryData<t.Action[]>([QueryKeys.actions], existingActions.concat(actions));
+        invalidateAgentMarketplaceQueries(queryClient);

        return options?.onSuccess?.({ agent, actions }, variables, context);
      },
@ -181,6 +193,8 @@ export const useUploadAgentAvatarMutation = (
  t.AgentAvatarVariables, // request
  unknown // context
 > => {
+  const queryClient = useQueryClient();
+
  return useMutation([MutationKeys.agentAvatarUpload], {
    mutationFn: ({ postCreation, ...variables }: t.AgentAvatarVariables) =>
      dataService.uploadAgentAvatar(variables),
@ -207,26 +221,25 @@ export const useUpdateAgentAction = (
    onMutate: (variables) => options?.onMutate?.(variables),
    onError: (error, variables, context) => options?.onError?.(error, variables, context),
    onSuccess: (updateAgentActionResponse, variables, context) => {
-      const listRes = queryClient.getQueryData<t.AgentListResponse>([
-        QueryKeys.agents,
-        defaultOrderQuery,
-      ]);
-
-      if (!listRes) {
-        return options?.onSuccess?.(updateAgentActionResponse, variables, context);
-      }
-
      const updatedAgent = updateAgentActionResponse[0];
+      ((keys: t.AgentListParams[]) => {
+        keys.forEach((key) => {
+          const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);

-      queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-        ...listRes,
-        data: listRes.data.map((agent) => {
-          if (agent.id === variables.agent_id) {
-            return updatedAgent;
+          if (!listRes) {
+            return options?.onSuccess?.(updateAgentActionResponse, variables, context);
          }
-          return agent;
-        }),
-      });
+          queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+            ...listRes,
+            data: listRes.data.map((agent) => {
+              if (agent.id === variables.agent_id) {
+                return updatedAgent;
+              }
+              return agent;
+            }),
+          });
+        });
+      })(allAgentViewAndEditQueryKeys);

      queryClient.setQueryData<t.Action[]>([QueryKeys.actions], (prev) => {
        if (!prev) {
@ -280,28 +293,28 @@ export const useDeleteAgentAction = (
          return action.action_id !== variables.action_id;
        });
      });
+      ((keys: t.AgentListParams[]) => {
+        keys.forEach((key) => {
+          queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], (prev) => {
+            if (!prev) {
+              return prev;
+            }

-      queryClient.setQueryData<t.AgentListResponse>(
-        [QueryKeys.agents, defaultOrderQuery],
-        (prev) => {
-          if (!prev) {
-            return prev;
-          }
-
-          return {
-            ...prev,
-            data: prev.data.map((agent) => {
-              if (agent.id === variables.agent_id) {
-                return {
-                  ...agent,
-                  tools: agent.tools?.filter((tool) => !tool.includes(domain ?? '')),
-                };
-              }
-              return agent;
-            }),
-          };
-        },
-      );
+            return {
+              ...prev,
+              data: prev.data.map((agent) => {
+                if (agent.id === variables.agent_id) {
+                  return {
+                    ...agent,
+                    tools: agent.tools?.filter((tool) => !tool.includes(domain ?? '')),
+                  };
+                }
+                return agent;
+              }),
+            };
+          });
+        });
+      })(allAgentViewAndEditQueryKeys);
      const updaterFn = (prev) => {
        if (!prev) {
          return prev;
@ -342,25 +355,30 @@ export const useRevertAgentVersionMutation = (
      onSuccess: (revertedAgent, variables, context) => {
        queryClient.setQueryData<t.Agent>([QueryKeys.agent, variables.agent_id], revertedAgent);

-        const listRes = queryClient.getQueryData<t.AgentListResponse>([
-          QueryKeys.agents,
-          defaultOrderQuery,
-        ]);
+        ((keys: t.AgentListParams[]) => {
+          keys.forEach((key) => {
+            const listRes = queryClient.getQueryData<t.AgentListResponse>([QueryKeys.agents, key]);

-        if (listRes) {
-          queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, defaultOrderQuery], {
-            ...listRes,
-            data: listRes.data.map((agent) => {
-              if (agent.id === variables.agent_id) {
-                return revertedAgent;
-              }
-              return agent;
-            }),
+            if (listRes) {
+              queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {
+                ...listRes,
+                data: listRes.data.map((agent) => {
+                  if (agent.id === variables.agent_id) {
+                    return revertedAgent;
+                  }
+                  return agent;
+                }),
+              });
+            }
          });
-        }
+        })(allAgentViewAndEditQueryKeys);

        return options?.onSuccess?.(revertedAgent, variables, context);
      },
    },
  );
 };
+
+export const invalidateAgentMarketplaceQueries = (queryClient: QueryClient) => {
+  queryClient.invalidateQueries([QueryKeys.marketplaceAgents]);
+};
--- a/client/src/data-provider/Agents/queries.ts
+++ b/client/src/data-provider/Agents/queries.ts
@ -1,4 +1,4 @@
-import { QueryKeys, dataService, EModelEndpoint, defaultOrderQuery } from 'librechat-data-provider';
+import { QueryKeys, dataService, EModelEndpoint, PERMISSION_BITS } from 'librechat-data-provider';
 import { useQuery, useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
 import type {
  QueryObserverResult,
@ -11,7 +11,10 @@ import type t from 'librechat-data-provider';
 /**
 * AGENTS
 */
-
+export const defaultAgentParams: t.AgentListParams = {
+  limit: 10,
+  requiredPermission: PERMISSION_BITS.EDIT,
+};
 /**
 * Hook for getting all available tools for A
 */
@ -32,7 +35,7 @@ export const useAvailableAgentToolsQuery = (): QueryObserverResult<t.TPlugin[]>
 * Hook for listing all Agents, with optional parameters provided for pagination and sorting
 */
 export const useListAgentsQuery = <TData = t.AgentListResponse>(
-  params: t.AgentListParams = defaultOrderQuery,
+  params: t.AgentListParams = defaultAgentParams,
  config?: UseQueryOptions<t.AgentListResponse, unknown, TData>,
 ): QueryObserverResult<TData> => {
  const queryClient = useQueryClient();
--- a/client/src/hooks/Agents/useAgentsMap.ts
+++ b/client/src/hooks/Agents/useAgentsMap.ts
@ -9,9 +9,7 @@ export default function useAgentsMap({
  isAuthenticated: boolean;
 }): TAgentsMap | undefined {
  const { data: agentsList = null } = useListAgentsQuery(
-    {
-      requiredPermission: PERMISSION_BITS.EDIT,
-    },
+    { requiredPermission: PERMISSION_BITS.EDIT },
    {
      select: (res) => mapAgents(res.data),
      enabled: isAuthenticated,
--- a/client/src/hooks/Input/useMentions.ts
+++ b/client/src/hooks/Input/useMentions.ts
@ -8,6 +8,7 @@ import {
  isAgentsEndpoint,
  getConfigDefaults,
  isAssistantsEndpoint,
+  PERMISSION_BITS,
 } from 'librechat-data-provider';
 import type { TAssistantsMap, TEndpointsConfig } from 'librechat-data-provider';
 import type { MentionOption } from '~/common';
@ -79,28 +80,31 @@ export default function useMentions({
    () => startupConfig?.interface ?? defaultInterface,
    [startupConfig?.interface],
  );
-  const { data: agentsList = null } = useListAgentsQuery(undefined, {
-    enabled: hasAgentAccess && interfaceConfig.modelSelect === true,
-    select: (res) => {
-      const { data } = res;
-      return data.map(({ id, name, avatar }) => ({
-        value: id,
-        label: name ?? '',
-        type: EModelEndpoint.agents,
-        icon: EndpointIcon({
-          conversation: {
-            agent_id: id,
-            endpoint: EModelEndpoint.agents,
-            iconURL: avatar?.filepath,
-          },
-          containerClassName: 'shadow-stroke overflow-hidden rounded-full',
-          endpointsConfig: endpointsConfig,
-          context: 'menu-item',
-          size: 20,
-        }),
-      }));
+  const { data: agentsList = null } = useListAgentsQuery(
+    { requiredPermission: PERMISSION_BITS.VIEW },
+    {
+      enabled: hasAgentAccess && interfaceConfig.modelSelect === true,
+      select: (res) => {
+        const { data } = res;
+        return data.map(({ id, name, avatar }) => ({
+          value: id,
+          label: name ?? '',
+          type: EModelEndpoint.agents,
+          icon: EndpointIcon({
+            conversation: {
+              agent_id: id,
+              endpoint: EModelEndpoint.agents,
+              iconURL: avatar?.filepath,
+            },
+            containerClassName: 'shadow-stroke overflow-hidden rounded-full',
+            endpointsConfig: endpointsConfig,
+            context: 'menu-item',
+            size: 20,
+          }),
+        }));
+      },
    },
-  });
+  );
  const assistantListMap = useMemo(
    () => ({
      [EModelEndpoint.assistants]: listMap[EModelEndpoint.assistants]