Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix: clean agent subgraphs and repair frontend requests (#22048)

buua43638725dc07048
diff --git a/web/src/hooks/__tests__/use-knowledge-metadata-keys.test.tsx b/web/src/hooks/__tests__/use-knowledge-metadata-keys.test.tsx
new file mode 100644
index 0000000000..27f4cab117
--- /dev/null
+++ b/web/src/hooks/__tests__/use-knowledge-metadata-keys.test.tsx
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { PropsWithChildren } from 'react';
+import kbService from '@/services/knowledge-service';
+import { useFetchKnowledgeMetadataKeys } from '../use-knowledge-request';
+
+describe('useFetchKnowledgeMetadataKeys', () => {
+ it('derives keys from the Go metadata endpoint with query parameters', async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ const getMeta = jest.spyOn(kbService, 'getMeta').mockResolvedValue({
+ data: {
+ code: 0,
+ data: {
+ author: { Alice: ['doc-1'] },
+ year: { '2026': ['doc-1'] },
+ },
+ },
+ } as never);
+ const wrapper = ({ children }: PropsWithChildren) => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+
+ const { result } = renderHook(
+ () => useFetchKnowledgeMetadataKeys(['dataset-2', 'dataset-1']),
+ { wrapper },
+ );
+
+ await waitFor(() => {
+ expect(result.current.data).toEqual(['author', 'year']);
+ });
+ expect(getMeta).toHaveBeenCalledWith({
+ dataset_ids: 'dataset-1,dataset-2',
+ });
+ queryClient.clear();
+ getMeta.mockRestore();
+ });
+});
diff --git a/web/src/hooks/use-knowledge-request.ts b/web/src/hooks/use-knowledge-request.ts
index b937c0ccbc..4017806868 100644
--- a/web/src/hooks/use-knowledge-request.ts
+++ b/web/src/hooks/use-knowledge-request.ts
@@ -106,7 +106,6 @@ export const enum KnowledgeApiAction {
FetchWikiCommits = 'fetchWikiCommits',
FetchWikiCommit = 'fetchWikiCommit',
FetchMetadata = 'fetchMetadata',
- FetchMetadataKeys = 'fetchMetadataKeys',
FetchKnowledgeList = 'fetchKnowledgeList',
RemoveKnowledgeGraph = 'removeKnowledgeGraph',
ClearWiki = 'clearWiki',
@@ -876,18 +875,8 @@ export function useFetchKnowledgeMetadata(kbIds: string[] = []) {
export function useFetchKnowledgeMetadataKeys(kbIds: string[] = []) {
const sortedKbIds = useMemo(() => [...kbIds].sort(), [kbIds]);
- const { data, isFetching: loading } = useQuery<string[]>({
- queryKey: [KnowledgeApiAction.FetchMetadataKeys, sortedKbIds],
- initialData: [],
- enabled: sortedKbIds.length > 0,
- gcTime: 0,
- queryFn: async () => {
- const { data } = await kbService.getMetaKeys({
- kb_ids: sortedKbIds.join(','),
- });
- return data?.data ?? [];
- },
- });
+ const { data: metadata, loading } = useFetchKnowledgeMetadata(sortedKbIds);
+ const data = useMemo(() => Object.keys(metadata), [metadata]);
return { data, loading };
}
diff --git a/web/src/pages/agent/store.test.ts b/web/src/pages/agent/store.test.ts
index f248d96814..e0611a12de 100644
--- a/web/src/pages/agent/store.test.ts
+++ b/web/src/pages/agent/store.test.ts
@@ -36,6 +36,45 @@ const createEdge = (
...options,
});
+describe('useGraphStore.deleteAgentDownstreamNodesById', () => {
+ beforeEach(() => {
+ useGraphStore.setState({ nodes: [], edges: [] });
+ });
+
+ it('removes every edge connected to deleted downstream nodes', () => {
+ const nodes = [
+ createNode('agent:root', Operator.Agent),
+ createNode('agent:child', Operator.Agent),
+ createNode('tool:child', Operator.Tool),
+ createNode('message:child', Operator.Message),
+ createNode('begin', Operator.Begin),
+ createNode('message:keep', Operator.Message),
+ ];
+ const edges = [
+ createEdge('root-agent', 'agent:root', 'agent:child', {
+ sourceHandle: NodeHandleId.AgentBottom,
+ }),
+ createEdge('agent-tool', 'agent:child', 'tool:child', {
+ sourceHandle: NodeHandleId.Tool,
+ }),
+ createEdge('tool-message', 'tool:child', 'message:child', {
+ sourceHandle: NodeHandleId.Tool,
+ }),
+ createEdge('unrelated', 'begin', 'message:keep'),
+ ];
+
+ useGraphStore.setState({ nodes, edges });
+ useGraphStore.getState().deleteAgentDownstreamNodesById('agent:root');
+
+ const state = useGraphStore.getState();
+ expect(state.nodes.map((node) => node.id)).toEqual([
+ 'begin',
+ 'message:keep',
+ ]);
+ expect(state.edges.map((edge) => edge.id)).toEqual(['unrelated']);
+ });
+});
+
describe('useGraphStore.deleteIterationNodeById', () => {
beforeEach(() => {
useGraphStore.setState({
diff --git a/web/src/pages/agent/utils/delete-node.ts b/web/src/pages/agent/utils/delete-node.ts
index 4f1c18ebc6..fab0f09e76 100644
--- a/web/src/pages/agent/utils/delete-node.ts
+++ b/web/src/pages/agent/utils/delete-node.ts
@@ -11,21 +11,12 @@ export function deleteAllDownstreamAgentsAndTool(
[nodeId],
);
- const downstreamAgentAndToolEdges = downstreamAgentAndToolNodeIds.reduce<
- Edge[]
- >((pre, cur) => {
- const relatedEdges = edges.filter(
- (x) => x.source === cur || x.target === cur,
- );
-
- relatedEdges.forEach((x) => {
- if (!pre.some((y) => y.id !== x.id)) {
- pre.push(x);
- }
- });
-
- return pre;
- }, []);
+ const downstreamNodeIdSet = new Set(downstreamAgentAndToolNodeIds);
+ const downstreamAgentAndToolEdges = edges.filter(
+ (edge) =>
+ downstreamNodeIdSet.has(edge.source) ||
+ downstreamNodeIdSet.has(edge.target),
+ );
return {
downstreamAgentAndToolNodeIds,
diff --git a/web/src/pages/memories/hooks.test.tsx b/web/src/pages/memories/hooks.test.tsx
new file mode 100644
index 0000000000..11fcb3f962
--- /dev/null
+++ b/web/src/pages/memories/hooks.test.tsx
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import { MemoryRouter, Route, Routes, useSearchParams } from 'react-router';
+import { useFetchMemoryDetail } from './hooks';
+
+const mockGetMemoryConfig = jest.fn();
+
+jest.mock('@/services/memory-service', () => ({
+ __esModule: true,
+ default: {
+ getMemoryConfig: (...args: unknown[]) => mockGetMemoryConfig(...args),
+ },
+}));
+
+describe('useFetchMemoryDetail', () => {
+ beforeEach(() => {
+ mockGetMemoryConfig.mockReset();
+ });
+
+ it('loads a shared memory through the configuration endpoint', async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ const responseData = {
+ id: 'memory-shared',
+ name: 'Shared memory',
+ memory_config: { top_k: 6 },
+ };
+ mockGetMemoryConfig.mockResolvedValue({
+ data: { code: 0, data: responseData },
+ });
+ const wrapper = ({ children }: { children?: unknown }) => (
+ <MemoryRouter initialEntries={['/memories?shared_id=memory-shared']}>
+ <QueryClientProvider client={queryClient}>
+ <Routes>
+ <Route path="/memories" element={children as JSX.Element} />
+ </Routes>
+ </QueryClientProvider>
+ </MemoryRouter>
+ );
+
+ const { result: paramsResult } = renderHook(
+ () => useSearchParams()[0].get('shared_id'),
+ { wrapper },
+ );
+ expect(paramsResult.current).toBe('memory-shared');
+
+ const { result } = renderHook(() => useFetchMemoryDetail('tenant-1'), {
+ wrapper,
+ });
+
+ await waitFor(() => {
+ expect(mockGetMemoryConfig).toHaveBeenCalled();
+ });
+ await waitFor(() => {
+ expect(result.current.data).toEqual(responseData);
+ });
+ expect(mockGetMemoryConfig).toHaveBeenCalledWith('memory-shared');
+ queryClient.clear();
+ });
+
+ it('loads a memory by route id through the configuration endpoint', async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false } },
+ });
+ const responseData = {
+ id: 'memory-1',
+ name: 'Memory',
+ memory_config: { top_k: 6 },
+ };
+ mockGetMemoryConfig.mockResolvedValue({
+ data: { code: 0, data: responseData },
+ });
+ const wrapper = ({ children }: { children?: unknown }) => (
+ <MemoryRouter initialEntries={['/memories/memory-1']}>
+ <QueryClientProvider client={queryClient}>
+ <Routes>
+ <Route path="/memories/:id" element={children as JSX.Element} />
+ </Routes>
+ </QueryClientProvider>
+ </MemoryRouter>
+ );
+
+ const { result } = renderHook(() => useFetchMemoryDetail(), { wrapper });
+
+ await waitFor(() => {
+ expect(result.current.data).toEqual(responseData);
+ });
+ expect(mockGetMemoryConfig).toHaveBeenCalledWith('memory-1');
+ queryClient.clear();
+ });
+});
diff --git a/web/src/pages/memories/hooks.ts b/web/src/pages/memories/hooks.ts
index 741c1de889..bc3e30b06c 100644
--- a/web/src/pages/memories/hooks.ts
+++ b/web/src/pages/memories/hooks.ts
@@ -174,30 +174,22 @@ export const useFetchMemoryFilters = () => {
return { data, isLoading, isError };
};
+/** Loads the memory configuration for a route or shared memory link. */
export const useFetchMemoryDetail = (tenantId?: string) => {
const { id } = useParams();
const [memoryParams] = useSearchParams();
const shared_id = memoryParams.get('shared_id');
const memoryId = id || shared_id;
- let param: { id: string | null; tenant_id?: string } = {
- id: memoryId,
- };
- if (shared_id) {
- param = {
- id: memoryId,
- tenant_id: tenantId,
- };
- }
- const fetchMemoryDetailFunc = shared_id
- ? memoryService.getMemoryDetailShare
- : memoryService.getMemoryDetail;
const { data, isLoading, isError } = useQuery<MemoryDetailResponse, Error>({
queryKey: ['memoryDetail', memoryId],
- enabled: !shared_id || !!tenantId,
+ enabled: !!memoryId && (!shared_id || !!tenantId),
queryFn: async () => {
- const { data: response } = await fetchMemoryDetailFunc(param);
+ if (!memoryId) {
+ throw new Error('Memory id is required');
+ }
+ const { data: response } = await memoryService.getMemoryConfig(memoryId);
if (response.code !== 0) {
throw new Error(response.message || 'Failed to fetch memory detail');
}
@@ -264,7 +256,7 @@ export const useUpdateMemory = () => {
return response.data;
},
- onSuccess: (data, variables) => {
+ onSuccess: (_data, variables) => {
message.success(t('message.updated'));
queryClient.invalidateQueries({
queryKey: ['memoryDetail', variables.id],
diff --git a/web/src/services/knowledge-service.ts b/web/src/services/knowledge-service.ts
index 24ce6990cc..afa4cb107c 100644
--- a/web/src/services/knowledge-service.ts
+++ b/web/src/services/knowledge-service.ts
@@ -38,7 +38,6 @@ const {
listTagByKnowledgeIds,
listPipelines,
getMeta,
- getMetaKeys,
retrievalTestShare,
} = api;
@@ -71,10 +70,6 @@ const methods = {
url: getMeta,
method: 'get',
},
- getMetaKeys: {
- url: getMetaKeys,
- method: 'get',
- },
retrievalTestShare: {
url: retrievalTestShare,
method: 'post',
diff --git a/web/src/services/memory-service.ts b/web/src/services/memory-service.ts
index 5dc325052a..19f9a193bf 100644
--- a/web/src/services/memory-service.ts
+++ b/web/src/services/memory-service.ts
@@ -28,7 +28,6 @@ const {
deleteMemoryMessage,
getMessageContent,
updateMessageState,
- // getMemoryDetailShare,
} = api;
const methods = {
createMemory: {