@lobehub/lobehub 2.0.0-next.110 → 2.0.0-next.112

package/packages/types/src/userMemory/layers.ts

@@ -0,0 +1,54 @@
+export interface UserMemoryTimestamps {
+  accessedAt: Date;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface UserMemoryContext extends UserMemoryTimestamps {
+  associatedObjects: Record<string, unknown>[] | null;
+  associatedSubjects: Record<string, unknown>[] | null;
+  currentStatus: string | null;
+  description: string | null;
+  descriptionVector: number[] | null;
+  id: string;
+  metadata: Record<string, unknown> | null;
+  scoreImpact: number | null;
+  scoreUrgency: number | null;
+  tags: string[] | null;
+  title: string | null;
+  titleVector: number[] | null;
+  type: string | null;
+  userId: string | null;
+  userMemoryIds: string[] | null;
+}
+
+export interface UserMemoryExperience extends UserMemoryTimestamps {
+  action: string | null;
+  actionVector: number[] | null;
+  id: string;
+  keyLearning: string | null;
+  keyLearningVector: number[] | null;
+  metadata: Record<string, unknown> | null;
+  possibleOutcome: string | null;
+  reasoning: string | null;
+  scoreConfidence: number | null;
+  situation: string | null;
+  situationVector: number[] | null;
+  tags: string[] | null;
+  type: string | null;
+  userId: string | null;
+  userMemoryId: string | null;
+}
+
+export interface UserMemoryPreference extends UserMemoryTimestamps {
+  conclusionDirectives: string | null;
+  conclusionDirectivesVector: number[] | null;
+  id: string;
+  metadata: Record<string, unknown> | null;
+  scorePriority: number | null;
+  suggestions: string | null;
+  tags: string[] | null;
+  type: string | null;
+  userId: string | null;
+  userMemoryId: string | null;
+}

package/packages/types/src/userMemory/shared.ts

@@ -0,0 +1,64 @@
+export enum RelationshipEnum {
+  Aunt = 'aunt',
+  Brother = 'brother',
+  Classmate = 'classmate',
+  Colleague = 'colleague',
+  Couple = 'couple',
+  Coworker = 'coworker',
+  Daughter = 'daughter',
+  Father = 'father',
+  Friend = 'friend',
+  Granddaughter = 'granddaughter',
+  Grandfather = 'grandfather',
+  Grandmother = 'grandmother',
+  Grandson = 'grandson',
+  Husband = 'husband',
+  Manager = 'manager',
+  Mentee = 'mentee',
+  Mentor = 'mentor',
+  Mother = 'mother',
+  Nephew = 'nephew',
+  Niece = 'niece',
+  Other = 'other',
+  Partner = 'partner',
+  Self = 'self',
+  Sibling = 'sibling',
+  Sister = 'sister',
+  Son = 'son',
+  Spouse = 'spouse',
+  Teammate = 'teammate',
+  Uncle = 'uncle',
+  Wife = 'wife',
+}
+
+export enum MergeStrategyEnum {
+  Merge = 'merge',
+  Replace = 'replace',
+}
+
+export enum IdentityTypeEnum {
+  Demographic = 'demographic',
+  Personal = 'personal',
+  Professional = 'professional',
+}
+
+export enum LayersEnum {
+  Activity = 'activity',
+  Context = 'context',
+  Experience = 'experience',
+  Identity = 'identity',
+  Preference = 'preference',
+}
+
+export enum TypesEnum {
+  Activity = 'activity',
+  Context = 'context',
+  Event = 'event',
+  Fact = 'fact',
+  Location = 'location',
+  Other = 'other',
+  People = 'people',
+  Preference = 'preference',
+  Technology = 'technology',
+  Topic = 'topic',
+}

package/packages/types/src/userMemory/tools.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+
+import { UserMemoryContext, UserMemoryExperience, UserMemoryPreference } from './layers';
+import {
+  IdentityTypeEnum,
+  LayersEnum,
+  MergeStrategyEnum,
+  RelationshipEnum,
+  TypesEnum,
+} from './shared';
+
+export const addMemoryBaseSchema = z.object({
+  details: z.string().describe('Optional detailed information'),
+  memoryCategory: z
+    .string()
+    .describe(
+      'Category of memory, describes the domain or context the memory belongs to, e.g. talking travel plan counts as `travel` category, all work related memories could be `work` category, except side projects, where we belongs to `project` category',
+    ),
+  // TODO: migrate to .enum() if we could move to
+  // zod v4
+  // Read more: https://zod.dev/api#enum
+  memoryLayer: z
+    .nativeEnum(LayersEnum)
+    .describe(
+      'Memory layer, must be one of `context`, `identity`, `preference`, `experience`, `activity`',
+    ),
+  memoryType: z
+    .nativeEnum(TypesEnum)
+    .describe(
+      'Type of memory, used to describe the specific nature or classification of the memory related to',
+    ),
+  summary: z.string().describe('Concise overview of this specific memory'),
+  title: z.string().describe('Brief descriptive title'),
+});
+
+export type AddMemoryBaseParams = z.infer<typeof addMemoryBaseSchema>;
+
+export const addExperienceMemorySchema = addMemoryBaseSchema.extend({
+  withExperience: z.object({
+    action: z
+      .string()
+      .nullable()
+      .describe('Narrative describing actions taken or behaviors exhibited'),
+    keyLearning: z
+      .string()
+      .nullable()
+      .describe('Narrative describing key insights or lessons learned'),
+    possibleOutcome: z
+      .string()
+      .nullable()
+      .describe('Narrative describing potential outcomes or learnings'),
+    reasoning: z
+      .string()
+      .nullable()
+      .describe('Narrative describing the thought process or motivations'),
+    scoreConfidence: z
+      .number()
+      .nullable()
+      .describe(
+        'Numeric score (0-1 or domain-specific) describing confidence in the experience details',
+      ),
+    situation: z.string().nullable().describe('Narrative describing the situation or event'),
+    tags: z.array(z.string()).describe('Model generated tags that summarize the experience facets'),
+  }),
+});
+
+export type AddExperienceMemoryParams = z.infer<typeof addExperienceMemorySchema>;
+
+export const addContextMemorySchema = addMemoryBaseSchema.extend({
+  withContext: z.object({
+    associatedObjects: z
+      .array(z.object({}))
+      .describe('describing involved roles, entities, or resources'),
+    associatedSubjects: z
+      .array(z.object({}))
+      .describe('describing involved roles, entities, or resources'),
+    currentStatus: z
+      .string()
+      .nullable()
+      .describe("High level status markers (e.g., 'active', 'pending')"),
+    description: z
+      .string()
+      .describe('Rich narrative describing the situation, timeline, or environment'),
+    scoreImpact: z
+      .number()
+      .nullable()
+      .describe('Numeric score (0-1 or domain-specific) describing importance'),
+    scoreUrgency: z
+      .number()
+      .nullable()
+      .describe('Numeric score (0-1 or domain-specific) describing urgency'),
+    tags: z.array(z.string()).describe('Model generated tags that summarize the context themes'),
+    title: z.string().nullable().describe('Optional synthesized context headline'),
+    type: z
+      .string()
+      .nullable()
+      .describe(
+        "High level context archetype (e.g., 'temporarily', 'private', 'questioning', 'formal', 'assistant', 'mentorship')",
+      ),
+  }),
+});
+
+export type AddContextMemoryParams = z.infer<typeof addContextMemorySchema>;
+
+export const addPreferenceMemorySchema = addMemoryBaseSchema.extend({
+  withPreference: z.object({
+    appContext: z
+      .object({
+        app: z.string().nullable().describe('App or product name this applies to'),
+        feature: z.string().nullable(),
+        route: z.string().nullable(),
+        surface: z.string().nullable().describe('e.g., chat, emails, code review, notes'),
+      })
+      .strict()
+      .describe('Application/surface specific preference, if any'),
+    conclusionDirectives: z
+      .string()
+      .describe(
+        "Direct, self-contained instruction to the assistant from the user's perspective (what to do, not how to implement)",
+      ),
+    extractedScopes: z
+      .array(z.string())
+      .describe('describing preference facets and applicable scopes'),
+    originContext: z
+      .object({
+        actor: z.string().nullable().describe("Who stated the preference; use 'User' for the user"),
+        applicableWhen: z.string().nullable().describe('Conditions where this preference applies'),
+        notApplicableWhen: z.string().nullable().describe('Conditions where it does not apply'),
+        scenario: z.string().nullable().describe('Applicable scenario or use case'),
+        trigger: z.string().nullable().describe('What prompted this preference'),
+      })
+      .strict()
+      .describe('Context of how/why this preference was expressed'),
+    scorePriority: z
+      .number()
+      .nullable()
+      .describe('Numeric prioritization weight where higher means more critical to respect'),
+    suggestions: z
+      .array(z.string())
+      .describe('Follow-up actions or assistant guidance derived from the preference'),
+    tags: z.array(z.string()).describe('Model generated tags that summarize the preference facets'),
+    type: z
+      .string()
+      .nullable()
+      .describe("High level preference classification (e.g., 'lifestyle', 'communication')"),
+  }),
+});
+
+export type AddPreferenceMemoryParams = z.infer<typeof addPreferenceMemorySchema>;
+
+export const addIdentityMemorySchema = addMemoryBaseSchema.extend({
+  withIdentity: z.object({
+    description: z
+      .string()
+      .describe(
+        "Rich narrative describing the person's background, roles, and attributes (required)",
+      ),
+    episodicDate: z
+      .string()
+      .nullable()
+      .describe(
+        'Optional ISO 8601 timestamp describing when this identity aspect is most relevant',
+      ),
+    relationship: z
+      .nativeEnum(RelationshipEnum)
+      .describe(
+        "Relationship of this identity to the user. Use 'self' when the identity is the user themselves",
+      ),
+    role: z
+      .string()
+      .nullable()
+      .describe("Short role label (e.g., 'software engineer', 'student', 'manager', 'mentor')"),
+    scoreConfidence: z
+      .number()
+      .nullable()
+      .describe('Model confidence (0-1) that this identity aspect is correct'),
+    sourceEvidence: z
+      .string()
+      .nullable()
+      .describe('Optional short quote or pointer to evidence in the current conversation'),
+    tags: z.array(z.string()).describe('Model generated tags that summarize the identity facets'),
+    type: z.nativeEnum(IdentityTypeEnum).describe('High level identity archetype'),
+  }),
+});
+
+export type AddIdentityMemoryParams = z.infer<typeof addIdentityMemorySchema>;
+
+export const updateIdentityMemorySchema = z.object({
+  id: z.string().describe('The ID of the identity entry to update'),
+  mergeStrategy: z
+    .nativeEnum(MergeStrategyEnum)
+    .describe('replace: overwrite all fields; merge: update only provided fields'),
+  set: z
+    .object({
+      description: z.string().optional(),
+      episodicDate: z.string().nullable().optional(),
+      relationship: z.nativeEnum(RelationshipEnum).optional(),
+      role: z.string().nullable().optional(),
+      scoreConfidence: z.number().nullable().optional(),
+      sourceEvidence: z.string().nullable().optional(),
+      tags: z.array(z.string()).optional(),
+      type: z.string().nullable().optional(),
+    })
+    .strict()
+    .describe('Fields to update'),
+});
+
+export type UpdateIdentityMemoryParams = z.infer<typeof updateIdentityMemorySchema>;
+
+export const removeIdentityMemorySchema = z.object({
+  id: z.string().describe('The ID of the identity entry to remove'),
+  reason: z.string().describe('Brief reasoning: incorrect, obsolete, or duplicate'),
+});
+
+export type RemoveIdentityMemoryParams = z.infer<typeof removeIdentityMemorySchema>;
+
+export const searchMemorySchema = z.object({
+  // TODO: we need to dynamically fetch the available categories/types from the backend
+  // memoryCategory: z.string().optional(),
+  // memoryType: z.string().optional(),
+  query: z.string(),
+  topK: z.object({
+    contexts: z.coerce.number().int().min(0),
+    experiences: z.coerce.number().int().min(0),
+    preferences: z.coerce.number().int().min(0),
+  }),
+});
+
+export type SearchMemoryParams = z.infer<typeof searchMemorySchema>;
+
+export interface SearchMemoryResult {
+  contexts: Array<Omit<UserMemoryContext, 'userId' | 'descriptionVector'>>;
+  experiences: Array<
+    Omit<UserMemoryExperience, 'userId' | 'actionVector' | 'situationVector' | 'keyLearningVector'>
+  >;
+  preferences: Array<Omit<UserMemoryPreference, 'userId' | 'conclusionDirectivesVector'>>;
+}
+
+export type RetrieveMemoryParams = SearchMemoryParams;
+export type RetrieveMemoryResult = SearchMemoryResult;

package/src/features/ChatList/Messages/index.tsx

@@ -7,6 +7,14 @@ import { useSearchParams } from 'next/navigation';
 import { MouseEvent, ReactNode, memo, use, useCallback, useEffect, useRef } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
+import {
+  VirtuaContext,
+  removeVirtuaVisibleItem,
+  upsertVirtuaVisibleItem,
+} from '@/features/ChatList/components/VirtualizedList/VirtuosoContext';
+import { getChatStoreState, useChatStore } from '@/store/chat';
+import { displayMessageSelectors, messageStateSelectors } from '@/store/chat/selectors';
+
 import ContextMenu from '../components/ContextMenu';
 import History from '../components/History';
 import { InPortalThreadContext } from '../context/InPortalThreadContext';
@@ -17,14 +25,6 @@ import SupervisorMessage from './Supervisor';
 import ToolMessage from './Tool';
 import UserMessage from './User';
 
-import {
-  VirtuaContext,
-  removeVirtuaVisibleItem,
-  upsertVirtuaVisibleItem,
-} from '@/features/ChatList/components/VirtualizedList/VirtuosoContext';
-import { getChatStoreState, useChatStore } from '@/store/chat';
-import { displayMessageSelectors, messageStateSelectors } from '@/store/chat/selectors';
-
 const useStyles = createStyles(({ css, prefixCls }) => ({
   loading: css`
     opacity: 0.6;
@@ -66,17 +66,14 @@ const Item = memo<ChatListItemProps>(
     const searchParams = useSearchParams();
     const topic = searchParams.get('topic');
 
-    const [role, editing, isMessageCreating] = useChatStore(
-      (s) => {
-        const item = displayMessageSelectors.getDisplayMessageById(id)(s);
-        return [
-          item?.role,
-          messageStateSelectors.isMessageEditing(id)(s),
-          messageStateSelectors.isMessageCreating(id)(s),
-        ];
-      },
-      isEqual,
-    );
+    const [role, editing, isMessageCreating] = useChatStore((s) => {
+      const item = displayMessageSelectors.getDisplayMessageById(id)(s);
+      return [
+        item?.role,
+        messageStateSelectors.isMessageEditing(id)(s),
+        messageStateSelectors.isMessageCreating(id)(s),
+      ];
+    }, isEqual);
 
     const {
       containerRef: contextMenuContainerRef,

package/src/features/ChatList/components/ContextMenu.tsx

@@ -7,13 +7,20 @@ import { Dropdown, type MenuProps } from 'antd';
 import { App } from 'antd';
 import { createStyles } from 'antd-style';
 import isEqual from 'fast-deep-equal';
-import { isValidElement, memo, useCallback, useMemo, useState, type RefObject , ComponentType, ReactNode } from 'react';
+import {
+  ComponentType,
+  ReactNode,
+  type RefObject,
+  isValidElement,
+  memo,
+  useCallback,
+  useMemo,
+  useState,
+} from 'react';
 import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
 import type { VListHandle } from 'virtua';
 
-import ShareMessageModal from './ShareMessageModal';
-import { useChatListActionsBar } from '../hooks/useChatListActionsBar';
 import { getChatStoreState, useChatStore } from '@/store/chat';
 import {
   displayMessageSelectors,
@@ -23,6 +30,9 @@ import {
 import { useSessionStore } from '@/store/session';
 import { sessionSelectors } from '@/store/session/selectors';
 
+import { useChatListActionsBar } from '../hooks/useChatListActionsBar';
+import ShareMessageModal from './ShareMessageModal';
+
 interface ActionMenuItem extends ActionIconGroupItemType {
   children?: { key: string; label: ReactNode }[];
   disable?: boolean;
@@ -76,19 +86,16 @@ const ContextMenu = memo<ContextMenuProps>(
     const [shareMessage, setShareMessage] = useState<UIChatMessage | null>(null);
     const [isShareModalOpen, setShareModalOpen] = useState(false);
 
-    const [role, error, isCollapsed, hasThread, isRegenerating] = useChatStore(
-      (s) => {
-        const item = displayMessageSelectors.getDisplayMessageById(id)(s);
-        return [
-          item?.role,
-          item?.error,
-          messageStateSelectors.isMessageCollapsed(id)(s),
-          threadSelectors.hasThreadBySourceMsgId(id)(s),
-          messageStateSelectors.isMessageRegenerating(id)(s),
-        ];
-      },
-      isEqual,
-    );
+    const [role, error, isCollapsed, hasThread, isRegenerating] = useChatStore((s) => {
+      const item = displayMessageSelectors.getDisplayMessageById(id)(s);
+      return [
+        item?.role,
+        item?.error,
+        messageStateSelectors.isMessageCollapsed(id)(s),
+        threadSelectors.hasThreadBySourceMsgId(id)(s),
+        messageStateSelectors.isMessageRegenerating(id)(s),
+      ];
+    }, isEqual);
 
     const isThreadMode = useChatStore((s) => !!s.activeThreadId);
     const isGroupSession = useSessionStore(sessionSelectors.isCurrentSessionGroupSession);

package/src/helpers/toolEngineering/index.ts

@@ -6,16 +6,16 @@ import type { PluginEnableChecker } from '@lobechat/context-engine';
 import { ChatCompletionTool, WorkingModel } from '@lobechat/types';
 import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 
+import { getAgentStoreState } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { getToolStoreState } from '@/store/tool';
 import { pluginSelectors } from '@/store/tool/selectors';
+import { KnowledgeBaseManifest } from '@/tools/knowledge-base';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
 
 import { getSearchConfig } from '../getSearchConfig';
 import { isCanUseFC } from '../isCanUseFC';
 import { shouldEnableTool } from '../toolFilters';
-import { KnowledgeBaseManifest } from '@/tools/knowledge-base';
-import { getAgentStoreState } from '@/store/agent';
-import { agentSelectors } from '@/store/agent/slices/chat';
 
 /**
  * Tools engine configuration options
@@ -59,11 +59,7 @@ export const createToolsEngine = (config: ToolsEngineConfig = {}): ToolsEngine =
 export const createAgentToolsEngine = (workingModel: WorkingModel) =>
   createToolsEngine({
     // Add default tools based on configuration
-    defaultToolIds: [
-      WebBrowsingManifest.identifier,
-      // Only add KnowledgeBase tool if knowledge is enabled
-      KnowledgeBaseManifest.identifier,
-    ],
+    defaultToolIds: [WebBrowsingManifest.identifier, KnowledgeBaseManifest.identifier],
     // Create search-aware enableChecker for this request
     enableChecker: ({ pluginId }) => {
       // Check platform-specific constraints (e.g., LocalSystem desktop-only)
@@ -80,7 +76,7 @@ export const createAgentToolsEngine = (workingModel: WorkingModel) =>
       if (pluginId === KnowledgeBaseManifest.identifier) {
         const agentState = getAgentStoreState();
 
-        return agentSelectors.hasEnabledKnowledge(agentState);
+        return agentSelectors.hasEnabledKnowledgeBases(agentState);
       }
 
       // For all other plugins, enable by default

package/src/hooks/useQueryParam.ts

@@ -85,28 +85,30 @@ export function useQueryParam<T>(
 
       const updateParams = () => {
         // 使用函数式更新，确保基于最新的 searchParams
-        setSearchParams((prevParams) => {
-          const newSearchParams = new URLSearchParams(prevParams);
-          console.log('updateParams', newSearchParams.toString());
-          const serialized = currentParser.serialize(actualValue);
-
-          // 处理 clearOnDefault 选项
-          if (
-            currentClearOnDefault &&
-            currentDefaultValue !== undefined &&
-            serialized === currentParser.serialize(currentDefaultValue as T)
-          ) {
-            newSearchParams.delete(key);
-          } else if (serialized === null || serialized === undefined) {
-            newSearchParams.delete(key);
-          } else {
-            newSearchParams.set(key, serialized);
-          }
-
-          console.log('updateParams', newSearchParams.toString());
-
-          return newSearchParams;
-        }, { replace: currentHistory === 'replace' });
+        setSearchParams(
+          (prevParams) => {
+            const newSearchParams = new URLSearchParams(prevParams);
+            const serialized = currentParser.serialize(actualValue);
+
+            // 处理 clearOnDefault 选项
+            if (
+              currentClearOnDefault &&
+              currentDefaultValue !== undefined &&
+              serialized === currentParser.serialize(currentDefaultValue as T)
+            ) {
+              newSearchParams.delete(key);
+            } else if (serialized === null || serialized === undefined) {
+              newSearchParams.delete(key);
+            } else {
+              newSearchParams.set(key, serialized);
+            }
+
+            console.log('updateParams', newSearchParams.toString());
+
+            return newSearchParams;
+          },
+          { replace: currentHistory === 'replace' },
+        );
       };
 
       // 处理节流

package/src/server/routers/async/file.ts

@@ -90,13 +90,8 @@ export const fileRouter = router({
           try {
             await pMap(
               requestArray,
-              async (chunks, index) => {
-                const agentRuntime = await initModelRuntimeWithUserPayload(
-                  provider,
-                  ctx.jwtPayload,
-                );
-
-                console.log(`run embedding task ${index + 1}`);
+              async (chunks) => {
+                const agentRuntime = initModelRuntimeWithUserPayload(provider, ctx.jwtPayload);
 
                 const embeddings = await agentRuntime.embeddings({
                   dimensions: 1024,

package/src/server/routers/lambda/chunk.ts

@@ -162,7 +162,12 @@ export const chunkRouter = router({
           }
 
           // 2. Find existing parsed document
-          let document = await ctx.documentModel.findByFileId(fileId);
+          let document:
+            | {
+                content: string | null;
+                metadata: Record<string, any> | null;
+              }
+            | undefined = await ctx.documentModel.findByFileId(fileId);
 
           // 3. If not exists, parse the file
           if (!document) {

package/src/services/chat/contextEngineering.ts

@@ -5,6 +5,7 @@ import {
   HistorySummaryProvider,
   HistoryTruncateProcessor,
   InputTemplateProcessor,
+  KnowledgeInjector,
   MessageCleanupProcessor,
   MessageContentProcessor,
   PlaceholderVariablesProcessor,
@@ -19,6 +20,8 @@ import { OpenAIChatMessage, UIChatMessage } from '@lobechat/types';
 import { VARIABLE_GENERATORS } from '@lobechat/utils/client';
 
 import { isCanUseFC } from '@/helpers/isCanUseFC';
+import { getAgentStoreState } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
 import { getToolStoreState } from '@/store/tool';
 import { toolSelectors } from '@/store/tool/selectors';
 
@@ -50,6 +53,19 @@ export const contextEngineering = async ({
 }: ContextEngineeringContext): Promise<OpenAIChatMessage[]> => {
   const toolNameResolver = new ToolNameResolver();
 
+  // Get enabled agent files with content and knowledge bases from agent store
+  const agentStoreState = getAgentStoreState();
+  const agentFiles = agentSelectors.currentAgentFiles(agentStoreState);
+  const agentKnowledgeBases = agentSelectors.currentAgentKnowledgeBases(agentStoreState);
+
+  const fileContents = agentFiles
+    .filter((file) => file.enabled && file.content)
+    .map((file) => ({ content: file.content!, fileId: file.id, filename: file.name }));
+
+  const knowledgeBases = agentKnowledgeBases
+    .filter((kb) => kb.enabled)
+    .map((kb) => ({ description: kb.description, id: kb.id, name: kb.name }));
+
   const pipeline = new ContextEngine({
     pipeline: [
       // 1. History truncation (MUST be first, before any message injection)
@@ -60,6 +76,9 @@ export const contextEngineering = async ({
       // 2. System role injection (agent's system role)
       new SystemRoleInjector({ systemRole }),
 
+      // 3. Knowledge injection (full content for agent files + metadata for knowledge bases)
+      new KnowledgeInjector({ fileContents, knowledgeBases }),
+
       // 4. Tool system role injection
       new ToolSystemRoleProvider({
         getToolSystemRoles: (tools) => toolSelectors.enabledSystemRoles(tools)(getToolStoreState()),

package/src/store/agent/slices/chat/selectors/agent.ts

@@ -152,6 +152,9 @@ const hasFiles = (s: AgentStoreState) => {
 
 const hasKnowledge = (s: AgentStoreState) => hasKnowledgeBases(s) || hasFiles(s);
 const hasEnabledKnowledge = (s: AgentStoreState) => currentEnabledKnowledge(s).length > 0;
+const hasEnabledKnowledgeBases = (s: AgentStoreState) =>
+  currentAgentKnowledgeBases(s).some((s) => s.enabled);
+
 const currentKnowledgeIds = (s: AgentStoreState) => {
   return {
     fileIds: currentAgentFiles(s)
@@ -185,6 +188,7 @@ export const agentSelectors = {
   getAgentConfigByAgentId,
   getAgentConfigById,
   hasEnabledKnowledge,
+  hasEnabledKnowledgeBases,
   hasKnowledge,
   hasSystemRole,
   inboxAgentConfig,