@lobehub/lobehub 2.0.0-next.97 → 2.0.0-next.99

package/src/store/chat/slices/aiChat/actions/__tests__/rag.test.ts

@@ -62,93 +62,6 @@ describe('chatRAG actions', () => {
     });
   });
 
-  describe('internal_retrieveChunks', () => {
-    it('should retrieve chunks with existing ragQuery', async () => {
-      const { result } = renderHook(() => useChatStore());
-      const messageId = 'message-id';
-      const existingRagQuery = 'existing-query';
-      const userQuery = 'user-query';
-
-      // Mock the message with existing ragQuery
-      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockReturnValue(
-        () =>
-          ({
-            id: messageId,
-            ragQuery: existingRagQuery,
-          }) as UIChatMessage,
-      );
-
-      // Mock the semantic search response
-      (ragService.semanticSearchForChat as Mock).mockResolvedValue({
-        chunks: [{ id: 'chunk-1' }],
-        queryId: 'query-id',
-      });
-
-      vi.spyOn(agentSelectors, 'currentKnowledgeIds').mockReturnValue({
-        fileIds: [],
-        knowledgeBaseIds: [],
-      });
-
-      const result1 = await act(async () => {
-        return await result.current.internal_retrieveChunks(messageId, userQuery, []);
-      });
-
-      expect(result1).toEqual({
-        chunks: [{ id: 'chunk-1' }],
-        queryId: 'query-id',
-        rewriteQuery: existingRagQuery,
-      });
-      expect(ragService.semanticSearchForChat).toHaveBeenCalledWith(
-        expect.objectContaining({
-          rewriteQuery: existingRagQuery,
-          userQuery,
-        }),
-      );
-    });
-
-    it('should rewrite query if no existing ragQuery', async () => {
-      const { result } = renderHook(() => useChatStore());
-      const messageId = 'message-id';
-      const userQuery = 'user-query';
-      const rewrittenQuery = 'rewritten-query';
-
-      // Mock the message without ragQuery
-      vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockReturnValue(
-        () =>
-          ({
-            id: messageId,
-          }) as UIChatMessage,
-      );
-
-      // Mock the rewrite query function
-      vi.spyOn(result.current, 'internal_rewriteQuery').mockResolvedValueOnce(rewrittenQuery);
-
-      // Mock the semantic search response
-      (ragService.semanticSearchForChat as Mock).mockResolvedValue({
-        chunks: [{ id: 'chunk-1' }],
-        queryId: 'query-id',
-      });
-
-      vi.spyOn(agentSelectors, 'currentKnowledgeIds').mockReturnValue({
-        fileIds: [],
-        knowledgeBaseIds: [],
-      });
-
-      const result2 = await act(async () => {
-        return await result.current.internal_retrieveChunks(messageId, userQuery, ['message']);
-      });
-
-      expect(result2).toEqual({
-        chunks: [{ id: 'chunk-1' }],
-        queryId: 'query-id',
-        rewriteQuery: rewrittenQuery,
-      });
-      expect(result.current.internal_rewriteQuery).toHaveBeenCalledWith(messageId, userQuery, [
-        'message',
-      ]);
-    });
-  });
-
   describe('internal_rewriteQuery', () => {
     it('should return original content if query rewrite is disabled', async () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/chat/slices/aiChat/actions/__tests__/streamingExecutor.test.ts

@@ -712,75 +712,8 @@ describe('StreamingExecutor actions', () => {
       );
     });
 
-    // TODO: This test is complex to set up properly with agent runtime and message creation
-    // The functionality is verified in the implementation (streamingExecutor.ts:725-728)
-    it.skip('should pass context to optimisticUpdateMessageRAG', async () => {
-      act(() => {
-        useChatStore.setState({
-          internal_execAgentRuntime: realExecAgentRuntime,
-          activeId: 'active-session',
-          activeTopicId: 'active-topic',
-        });
-      });
-
-      const { result } = renderHook(() => useChatStore());
-
-      const contextSessionId = 'context-session';
-      const contextTopicId = 'context-topic';
-      const userMessage = {
-        id: TEST_IDS.USER_MESSAGE_ID,
-        role: 'user',
-        content: TEST_CONTENT.USER_MESSAGE,
-        sessionId: contextSessionId,
-        topicId: contextTopicId,
-      } as UIChatMessage;
-
-      const ragMetadata = {
-        ragQueryId: 'query-id',
-        fileChunks: [{ id: 'chunk-1', similarity: 0.9 }],
-      };
-
-      const assistantMessageId = 'assistant-msg-id';
-      const assistantMessage = {
-        id: assistantMessageId,
-        role: 'assistant',
-        content: TEST_CONTENT.AI_RESPONSE,
-        sessionId: contextSessionId,
-        topicId: contextTopicId,
-      } as UIChatMessage;
-
-      // Mock createMessage to return the assistant message
-      vi.spyOn(messageService, 'createMessage').mockResolvedValue({
-        id: assistantMessageId,
-        messages: [userMessage, assistantMessage],
-      });
-
-      const updateRAGSpy = vi.spyOn(result.current, 'optimisticUpdateMessageRAG');
-      const streamSpy = vi
-        .spyOn(chatService, 'createAssistantMessageStream')
-        .mockImplementation(async ({ onFinish }) => {
-          await onFinish?.(TEST_CONTENT.AI_RESPONSE, {});
-        });
-
-      await act(async () => {
-        await result.current.internal_execAgentRuntime({
-          messages: [userMessage],
-          parentMessageId: userMessage.id,
-          parentMessageType: 'user',
-          sessionId: contextSessionId,
-          topicId: contextTopicId,
-          ragMetadata,
-        });
-      });
-
-      // Verify optimisticUpdateMessageRAG was called with context
-      expect(updateRAGSpy).toHaveBeenCalledWith(expect.any(String), ragMetadata, {
-        sessionId: contextSessionId,
-        topicId: contextTopicId,
-      });
-
-      streamSpy.mockRestore();
-    });
+    // Note: RAG metadata functionality has been removed
+    // RAG is now handled by Knowledge Base Tools (searchKnowledgeBase and readKnowledge)
   });
 
   describe('StreamingExecutor OptimisticUpdateContext isolation', () => {

package/src/store/chat/slices/aiChat/actions/conversationLifecycle.ts

@@ -272,7 +272,6 @@ export const conversationLifecycle: StateCreator<
         sessionId: activeId,
         topicId: data.topicId ?? activeTopicId,
         parentOperationId: operationId, // Pass as parent operation
-        ragQuery: get().internal_shouldUseRAG() ? message : undefined,
         threadId: activeThreadId,
         skipCreateFirstMessage: true,
       });
@@ -338,7 +337,6 @@ export const conversationLifecycle: StateCreator<
         sessionId: activeId,
         topicId: activeTopicId,
         traceId,
-        ragQuery: get().internal_shouldUseRAG() ? item.content : undefined,
         threadId: activeThreadId,
         parentOperationId: operationId,
       });

package/src/store/chat/slices/aiChat/actions/rag.ts

@@ -10,18 +10,9 @@ import { dbMessageSelectors, displayMessageSelectors } from '@/store/chat/select
 import { toggleBooleanList } from '@/store/chat/utils';
 import { useUserStore } from '@/store/user';
 import { systemAgentSelectors } from '@/store/user/selectors';
-import { ChatSemanticSearchChunk } from '@/types/chunk';
 
 export interface ChatRAGAction {
   deleteUserMessageRagQuery: (id: string) => Promise<void>;
-  /**
-   * Retrieve chunks from semantic search
-   */
-  internal_retrieveChunks: (
-    id: string,
-    userQuery: string,
-    messages: string[],
-  ) => Promise<{ chunks: ChatSemanticSearchChunk[]; queryId?: string; rewriteQuery?: string }>;
   /**
    * Rewrite user content to better RAG query
    */
@@ -35,7 +26,6 @@ export interface ChatRAGAction {
   rewriteQuery: (id: string) => Promise<void>;
 }
 
-const knowledgeIds = () => agentSelectors.currentKnowledgeIds(useAgentStore.getState());
 const hasEnabledKnowledge = () => agentSelectors.hasEnabledKnowledge(useAgentStore.getState());
 
 export const chatRag: StateCreator<ChatStore, [['zustand/devtools', never]], [], ChatRAGAction> = (
@@ -58,43 +48,6 @@ export const chatRag: StateCreator<ChatStore, [['zustand/devtools', never]], [],
     await get().refreshMessages();
   },
 
-  internal_retrieveChunks: async (id, userQuery, messages) => {
-    get().internal_toggleMessageRAGLoading(true, id);
-
-    const message = dbMessageSelectors.getDbMessageById(id)(get());
-
-    // 1. get the rewrite query
-    let rewriteQuery = message?.ragQuery as string | undefined;
-
-    // if there is no ragQuery and there is a chat history
-    // we need to rewrite the user message to get better results
-    if (!message?.ragQuery && messages.length > 0) {
-      rewriteQuery = await get().internal_rewriteQuery(id, userQuery, messages);
-    }
-
-    // 2. retrieve chunks from semantic search
-    const files = dbMessageSelectors
-      .dbUserFiles(get())
-      .map((f) => f?.id)
-      .filter(Boolean) as string[];
-    try {
-      const { chunks, queryId } = await ragService.semanticSearchForChat({
-        fileIds: knowledgeIds().fileIds.concat(files),
-        knowledgeIds: knowledgeIds().knowledgeBaseIds,
-        messageId: id,
-        rewriteQuery: rewriteQuery || userQuery,
-        userQuery,
-      });
-
-      get().internal_toggleMessageRAGLoading(false, id);
-
-      return { chunks, queryId, rewriteQuery };
-    } catch {
-      get().internal_toggleMessageRAGLoading(false, id);
-
-      return { chunks: [] };
-    }
-  },
   internal_rewriteQuery: async (id, content, messages) => {
     let rewriteQuery = content;
 

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -2,7 +2,6 @@
 // Disable the auto sort key eslint rule to make the code more logic and readable
 import { AgentRuntime, type AgentRuntimeContext, type AgentState } from '@lobechat/agent-runtime';
 import { isDesktop } from '@lobechat/const';
-import { knowledgeBaseQAPrompts } from '@lobechat/prompts';
 import {
   ChatImageItem,
   ChatToolPayload,
@@ -11,19 +10,18 @@ import {
   TraceNameMap,
   UIChatMessage,
 } from '@lobechat/types';
-import type { MessageSemanticSearchChunk } from '@lobechat/types';
 import debug from 'debug';
 import { t } from 'i18next';
 import { throttle } from 'lodash-es';
 import { StateCreator } from 'zustand/vanilla';
 
+import { createAgentToolsEngine } from '@/helpers/toolEngineering';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
 import { getAgentStoreState } from '@/store/agent/store';
 import { GeneralChatAgent } from '@/store/chat/agents/GeneralChatAgent';
 import { createAgentExecutors } from '@/store/chat/agents/createAgentExecutors';
-import { createAgentToolsEngine } from '@/store/chat/agents/createToolEngine';
 import { ChatStore } from '@/store/chat/store';
 import { getFileStoreState } from '@/store/file/store';
 import { toolInterventionSelectors } from '@/store/user/selectors';
@@ -104,15 +102,10 @@ export interface StreamingExecutorAction {
      */
     parentOperationId?: string;
     inSearchWorkflow?: boolean;
-    /**
-     * the RAG query content, should be embedding and used in the semantic search
-     */
-    ragQuery?: string;
     threadId?: string;
     inPortalThread?: boolean;
     skipCreateFirstMessage?: boolean;
     traceId?: string;
-    ragMetadata?: { ragQueryId: string; fileChunks: MessageSemanticSearchChunk[] };
     /**
      * Initial agent state (for resuming execution from a specific point)
      */
@@ -624,59 +617,17 @@ export const streamingExecutor: StateCreator<
     const provider = agentConfigData.provider;
 
     // ===========================================
-    // Step 1: RAG Preprocessing (if enabled)
+    // Step 1: Knowledge Base Tool Integration
     // ===========================================
-    // Skip RAG preprocessing if initialState is provided (messages already preprocessed)
-    if (params.ragQuery && parentMessageType === 'user') {
-      const userMessageId = parentMessageId;
-      log('[internal_execAgentRuntime] RAG preprocessing start');
-
-      // Get relevant chunks from semantic search
-      const {
-        chunks,
-        queryId: ragQueryId,
-        rewriteQuery,
-      } = await get().internal_retrieveChunks(
-        userMessageId,
-        params.ragQuery,
-        // Skip the last message content when building context
-        messages.map((m) => m.content).slice(0, messages.length - 1),
-      );
-
-      log('[internal_execAgentRuntime] RAG chunks retrieved: %d chunks', chunks.length);
-
-      const lastMsg = messages.pop() as UIChatMessage;
-
-      // Build RAG context and append to user query
-      const knowledgeBaseQAContext = knowledgeBaseQAPrompts({
-        chunks,
-        userQuery: lastMsg.content,
-        rewriteQuery,
-        knowledge: agentSelectors.currentEnabledKnowledge(agentStoreState),
-      });
-
-      messages.push({
-        ...lastMsg,
-        content: (lastMsg.content + '\n\n' + knowledgeBaseQAContext).trim(),
-      });
+    // RAG retrieval is now handled by the Knowledge Base Tool
+    // The AI will decide when to call searchKnowledgeBase and readKnowledge tools
+    // based on the conversation context and available knowledge bases
 
-      // Update assistant message with RAG metadata
-      const fileChunks: MessageSemanticSearchChunk[] = chunks.map((c) => ({
-        id: c.id,
-        similarity: c.similarity,
-      }));
-
-      if (fileChunks.length > 0) {
-        // Note: RAG metadata will be updated after assistant message is created by call_llm executor
-        // Store RAG data temporarily in params for later use
-        params.ragMetadata = { ragQueryId: ragQueryId!, fileChunks };
-      }
-
-      log('[internal_execAgentRuntime] RAG preprocessing completed');
-    }
+    // TODO: Implement selected files full-text injection if needed
+    // User-selected files should be handled differently from knowledge base files
 
     // ===========================================
-    // Step 3: Create and Execute Agent Runtime
+    // Step 2: Create and Execute Agent Runtime
     // ===========================================
     log('[internal_execAgentRuntime] Creating agent runtime');
 
@@ -829,18 +780,6 @@ export const streamingExecutor: StateCreator<
       stepCount,
     );
 
-    // Update RAG metadata if available
-    if (params.ragMetadata) {
-      const finalMessages = get().messagesMap[messageKey] || [];
-      const assistantMessage = finalMessages.findLast((m) => m.role === 'assistant');
-      if (assistantMessage) {
-        await get().optimisticUpdateMessageRAG(assistantMessage.id, params.ragMetadata, {
-          operationId,
-        });
-        log('[internal_execAgentRuntime] RAG metadata updated for assistant message');
-      }
-    }
-
     // Complete operation
     if (state.status === 'done') {
       get().completeOperation(operationId);

package/src/store/chat/slices/builtinTool/actions/index.ts

@@ -3,13 +3,15 @@ import { StateCreator } from 'zustand/vanilla';
 import { ChatStore } from '@/store/chat/store';
 
 import { ChatCodeInterpreterAction, codeInterpreterSlice } from './interpreter';
+import { KnowledgeBaseAction, knowledgeBaseSlice } from './knowledgeBase';
 import { LocalFileAction, localSystemSlice } from './localSystem';
 import { SearchAction, searchSlice } from './search';
 
 export interface ChatBuiltinToolAction
   extends SearchAction,
     LocalFileAction,
-    ChatCodeInterpreterAction {}
+    ChatCodeInterpreterAction,
+    KnowledgeBaseAction {}
 
 export const chatToolSlice: StateCreator<
   ChatStore,
@@ -20,4 +22,5 @@ export const chatToolSlice: StateCreator<
   ...searchSlice(...params),
   ...localSystemSlice(...params),
   ...codeInterpreterSlice(...params),
+  ...knowledgeBaseSlice(...params),
 });

package/src/store/chat/slices/builtinTool/actions/knowledgeBase.ts

@@ -0,0 +1,174 @@
+import debug from 'debug';
+import { StateCreator } from 'zustand/vanilla';
+
+import { agentSelectors } from '@/store/agent/selectors';
+import { getAgentStoreState } from '@/store/agent/store';
+import { ChatStore } from '@/store/chat/store';
+import { KnowledgeBaseExecutionRuntime } from '@/tools/knowledge-base/ExecutionRuntime';
+
+import { dbMessageSelectors } from '../../message/selectors';
+
+const log = debug('lobe-store:builtin-tool:knowledge-base');
+
+export interface KnowledgeBaseAction {
+  internal_triggerKnowledgeBaseToolCalling: (
+    id: string,
+    callingService: () => Promise<{ content: string; error?: any; state?: any; success: boolean }>,
+  ) => Promise<boolean>;
+
+  /**
+   * Read full content of specific files from knowledge base
+   */
+  readKnowledge: (
+    id: string,
+    params: {
+      fileIds: string[];
+    },
+  ) => Promise<boolean>;
+
+  /**
+   * Search knowledge base for relevant files and chunks
+   */
+  searchKnowledgeBase: (
+    id: string,
+    params: {
+      query: string;
+      topK?: number;
+    },
+  ) => Promise<boolean>;
+}
+
+const runtime = new KnowledgeBaseExecutionRuntime();
+
+/* eslint-disable sort-keys-fix/sort-keys-fix */
+export const knowledgeBaseSlice: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  KnowledgeBaseAction
+> = (set, get) => ({
+  readKnowledge: async (id, params) => {
+    return get().internal_triggerKnowledgeBaseToolCalling(id, async () => {
+      return await runtime.readKnowledge(params);
+    });
+  },
+
+  searchKnowledgeBase: async (id, params) => {
+    // Get knowledge base IDs and file IDs from agent store
+    const agentState = getAgentStoreState();
+    const knowledgeIds = agentSelectors.currentKnowledgeIds(agentState);
+
+    // Get user-selected files from messages
+    const userFiles = dbMessageSelectors
+      .dbUserFiles(get())
+      .map((f) => f?.id)
+      .filter(Boolean) as string[];
+
+    // Merge knowledge base files and user-selected files
+    const options = {
+      fileIds: [...knowledgeIds.fileIds, ...userFiles],
+      knowledgeBaseIds: knowledgeIds.knowledgeBaseIds,
+    };
+
+    return get().internal_triggerKnowledgeBaseToolCalling(id, async () => {
+      return await runtime.searchKnowledgeBase(params, {
+        fileIds: options.fileIds,
+        knowledgeBaseIds: options.knowledgeBaseIds,
+        messageId: id,
+      });
+    });
+  },
+
+  // ==================== utils ====================
+
+  internal_triggerKnowledgeBaseToolCalling: async (id, callingService) => {
+    // Get parent operationId from messageOperationMap (should be executeToolCall)
+    const parentOperationId = get().messageOperationMap[id];
+
+    // Create child operation for knowledge base execution
+    // Auto-associates message with this operation via messageId in context
+    const { operationId: knowledgeBaseOpId, abortController } = get().startOperation({
+      context: {
+        messageId: id,
+      },
+      metadata: {
+        startTime: Date.now(),
+      },
+      parentOperationId,
+      type: 'builtinToolKnowledgeBase',
+    });
+
+    log(
+      '[knowledgeBase] messageId=%s, parentOpId=%s, knowledgeBaseOpId=%s, aborted=%s',
+      id,
+      parentOperationId,
+      knowledgeBaseOpId,
+      abortController.signal.aborted,
+    );
+
+    const context = { operationId: knowledgeBaseOpId };
+
+    try {
+      const { state, content, success, error } = await callingService();
+
+      // Complete knowledge base operation
+      get().completeOperation(knowledgeBaseOpId);
+
+      if (success) {
+        if (state) {
+          await get().optimisticUpdatePluginState(id, state, context);
+        }
+        await get().optimisticUpdateMessageContent(id, content, undefined, context);
+      } else {
+        await get().optimisticUpdateMessagePluginError(
+          id,
+          {
+            body: error,
+            message: error?.message || 'Operation failed',
+            type: 'PluginServerError',
+          },
+          context,
+        );
+        // Still update content even if failed, to show error message
+        await get().optimisticUpdateMessageContent(id, content, undefined, context);
+      }
+
+      return true;
+    } catch (error) {
+      const err = error as Error;
+
+      log('[knowledgeBase] Error: messageId=%s, error=%s', id, err.message);
+
+      // Check if it's an abort error
+      if (err.message.includes('The user aborted a request.') || err.name === 'AbortError') {
+        log('[knowledgeBase] Request aborted: messageId=%s', id);
+        // Fail knowledge base operation for abort
+        get().failOperation(knowledgeBaseOpId, {
+          message: 'User cancelled the request',
+          type: 'UserAborted',
+        });
+        // Don't update error message for user aborts
+        return false;
+      }
+
+      // Fail knowledge base operation for other errors
+      get().failOperation(knowledgeBaseOpId, {
+        message: err.message,
+        type: 'PluginServerError',
+      });
+
+      // For other errors, update message
+      await get().optimisticUpdateMessagePluginError(
+        id,
+        {
+          body: error,
+          message: err.message,
+          type: 'PluginServerError',
+        },
+        context,
+      );
+
+      return false;
+    }
+  },
+});

package/src/store/chat/slices/operation/types.ts

@@ -36,6 +36,7 @@ export type OperationType =
   | 'builtinToolSearch' // Builtin tool: search
   | 'builtinToolInterpreter' // Builtin tool: code interpreter
   | 'builtinToolLocalSystem' // Builtin tool: local system
+  | 'builtinToolKnowledgeBase' // Builtin tool: knowledge base
 
   // === Group Chat ===
   | 'supervisorDecision' // Supervisor decision

package/src/store/chat/slices/thread/action.test.ts

@@ -883,7 +883,6 @@ describe('thread action', () => {
             parentMessageId: 'new-msg-id',
             parentMessageType: 'user',
             inPortalThread: true,
-            ragQuery: 'test with rag',
             threadId: 'existing-thread-id',
           }),
         );

package/src/store/chat/slices/thread/action.ts

@@ -178,7 +178,6 @@ export const chatThreadMessage: StateCreator<
       parentMessageType: 'user',
       sessionId: get().activeId,
       topicId: get().activeTopicId,
-      ragQuery: get().internal_shouldUseRAG() ? message : undefined,
       threadId: get().portalThreadId,
       inPortalThread: true,
     });

package/src/tools/executionRuntimes.ts

@@ -1,9 +1,12 @@
+import { KnowledgeBaseManifest } from './knowledge-base';
+import { KnowledgeBaseExecutionRuntime } from './knowledge-base/ExecutionRuntime';
 import { LocalSystemManifest } from './local-system';
 import { LocalSystemExecutionRuntime } from './local-system/ExecutionRuntime';
 import { WebBrowsingManifest } from './web-browsing';
 import { WebBrowsingExecutionRuntime } from './web-browsing/ExecutionRuntime';
 
 export const BuiltinToolServerRuntimes: Record<string, any> = {
+  [KnowledgeBaseManifest.identifier]: KnowledgeBaseExecutionRuntime,
   [LocalSystemManifest.identifier]: LocalSystemExecutionRuntime,
   [WebBrowsingManifest.identifier]: WebBrowsingExecutionRuntime,
 };

package/src/tools/identifiers.ts

@@ -0,0 +1,13 @@
+import { ArtifactsManifest } from './artifacts';
+import { CodeInterpreterManifest } from './code-interpreter';
+import { KnowledgeBaseManifest } from './knowledge-base';
+import { LocalSystemManifest } from './local-system';
+import { WebBrowsingManifest } from './web-browsing';
+
+export const builtinToolIdentifiers: string[] = [
+  ArtifactsManifest.identifier,
+  LocalSystemManifest.identifier,
+  WebBrowsingManifest.identifier,
+  KnowledgeBaseManifest.identifier,
+  CodeInterpreterManifest.identifier,
+];

package/src/tools/index.ts

@@ -4,6 +4,7 @@ import { isDesktop } from '@/const/version';
 
 import { ArtifactsManifest } from './artifacts';
 import { CodeInterpreterManifest } from './code-interpreter';
+import { KnowledgeBaseManifest } from './knowledge-base';
 import { LocalSystemManifest } from './local-system';
 import { WebBrowsingManifest } from './web-browsing';
 
@@ -30,4 +31,10 @@ export const builtinTools: LobeBuiltinTool[] = [
     manifest: CodeInterpreterManifest,
     type: 'builtin',
   },
+  {
+    hidden: true,
+    identifier: KnowledgeBaseManifest.identifier,
+    manifest: KnowledgeBaseManifest,
+    type: 'builtin',
+  },
 ];