@lobehub/lobehub 2.0.0-next.320 → 2.0.0-next.322

package/src/features/PageEditor/PageEditor.tsx

@@ -15,6 +15,7 @@ import { builtinAgentSelectors } from '@/store/agent/selectors';
 import { useDocumentStore } from '@/store/document';
 import { editorSelectors } from '@/store/document/slices/editor';
 import { usePageStore } from '@/store/page';
+import { StyleSheet } from '@/utils/styles';
 
 import Copilot from './Copilot';
 import EditorCanvas from './EditorCanvas';
@@ -25,6 +26,22 @@ import PageTitle from './PageTitle';
 import TitleSection from './TitleSection';
 import { usePageEditorStore } from './store';
 
+const styles = StyleSheet.create({
+  contentWrapper: {
+    display: 'flex',
+    overflowY: 'auto',
+    position: 'relative',
+  },
+  editorContainer: {
+    minWidth: 0,
+    position: 'relative',
+  },
+  editorContent: {
+    overflowY: 'auto',
+    position: 'relative',
+  },
+});
+
 interface PageEditorProps {
   emoji?: string;
   knowledgeBaseId?: string;
@@ -77,16 +94,11 @@ const PageEditorCanvas = memo(() => {
         style={{ backgroundColor: cssVar.colorBgContainer }}
         width={'100%'}
       >
-        <Flexbox flex={1} height={'100%'} style={{ position: 'relative' }}>
+        <Flexbox flex={1} height={'100%'} style={styles.editorContainer}>
           <Header />
-          <Flexbox
-            height={'100%'}
-            horizontal
-            style={{ display: 'flex', overflowY: 'auto', position: 'relative' }}
-            width={'100%'}
-          >
+          <Flexbox height={'100%'} horizontal style={styles.contentWrapper} width={'100%'}>
             <WideScreenContainer onClick={() => editor?.focus()} wrapperStyle={{ cursor: 'text' }}>
-              <Flexbox flex={1} style={{ overflowY: 'auto', position: 'relative' }}>
+              <Flexbox flex={1} style={styles.editorContent}>
                 <TitleSection />
                 <EditorCanvas />
               </Flexbox>

package/src/layout/GlobalProvider/FaviconProvider.tsx

@@ -1,22 +1,34 @@
 'use client';
 
-import { type ReactNode, createContext, memo, useCallback, useContext, useState } from 'react';
+import { type ReactNode, createContext, memo, useCallback, useContext, useMemo, useState } from 'react';
 
 export type FaviconState = 'default' | 'done' | 'error' | 'progress';
 
-interface FaviconContextValue {
+interface FaviconStateContextValue {
   currentState: FaviconState;
   isDevMode: boolean;
+}
+
+interface FaviconSettersContextValue {
   setFavicon: (state: FaviconState) => void;
   setIsDevMode: (isDev: boolean) => void;
 }
 
-const FaviconContext = createContext<FaviconContextValue | null>(null);
+const FaviconStateContext = createContext<FaviconStateContextValue | null>(null);
+const FaviconSettersContext = createContext<FaviconSettersContextValue | null>(null);
+
+export const useFaviconState = () => {
+  const context = useContext(FaviconStateContext);
+  if (!context) {
+    throw new Error('useFaviconState must be used within FaviconProvider');
+  }
+  return context;
+};
 
-export const useFavicon = () => {
-  const context = useContext(FaviconContext);
+export const useFaviconSetters = () => {
+  const context = useContext(FaviconSettersContext);
   if (!context) {
-    throw new Error('useFavicon must be used within FaviconProvider');
+    throw new Error('useFaviconSetters must be used within FaviconProvider');
   }
   return context;
 };
@@ -66,26 +78,38 @@ export const FaviconProvider = memo<{ children: ReactNode }>(({ children }) => {
   const [currentState, setCurrentState] = useState<FaviconState>('default');
   const [isDevMode, setIsDevModeState] = useState<boolean>(defaultIsDev);
 
-  const setFavicon = useCallback(
-    (state: FaviconState) => {
-      setCurrentState(state);
-      updateFaviconDOM(state, isDevMode);
-    },
-    [isDevMode],
+  const setFavicon = useCallback((state: FaviconState) => {
+    setCurrentState(state);
+    setIsDevModeState((isDev) => {
+      updateFaviconDOM(state, isDev);
+      return isDev;
+    });
+  }, []);
+
+  const setIsDevMode = useCallback((isDev: boolean) => {
+    setIsDevModeState(isDev);
+    setCurrentState((state) => {
+      updateFaviconDOM(state, isDev);
+      return state;
+    });
+  }, []);
+
+  const stateValue = useMemo(
+    () => ({ currentState, isDevMode }),
+    [currentState, isDevMode],
   );
 
-  const setIsDevMode = useCallback(
-    (isDev: boolean) => {
-      setIsDevModeState(isDev);
-      updateFaviconDOM(currentState, isDev);
-    },
-    [currentState],
+  const settersValue = useMemo(
+    () => ({ setFavicon, setIsDevMode }),
+    [setFavicon, setIsDevMode],
   );
 
   return (
-    <FaviconContext.Provider value={{ currentState, isDevMode, setFavicon, setIsDevMode }}>
-      {children}
-    </FaviconContext.Provider>
+    <FaviconStateContext.Provider value={stateValue}>
+      <FaviconSettersContext.Provider value={settersValue}>
+        {children}
+      </FaviconSettersContext.Provider>
+    </FaviconStateContext.Provider>
   );
 });
 

package/src/server/globalConfig/parseMemoryExtractionConfig.ts

@@ -32,12 +32,18 @@ export type MemoryLayerExtractorConfig = MemoryLayerExtractorPublicConfig &
 
 export interface MemoryExtractionPrivateConfig {
   agentGateKeeper: MemoryAgentConfig;
+  agentGateKeeperPreferredModels?: string[];
+  agentGateKeeperPreferredProviders?: string[];
   agentLayerExtractor: MemoryLayerExtractorConfig;
+  agentLayerExtractorPreferredModels?: string[];
+  agentLayerExtractorPreferredProviders?: string[];
   concurrency?: number;
   embedding: MemoryAgentConfig;
+  embeddingPreferredModels?: string[];
+  embeddingPreferredProviders?: string[];
   featureFlags: {
     enableBenchmarkLoCoMo: boolean;
-  },
+  };
   observabilityS3?: {
     accessKeyId?: string;
     bucketName?: string;
@@ -157,6 +163,12 @@ const sanitizeAgent = (agent?: MemoryAgentConfig): MemoryAgentPublicConfig | und
   return sanitized as MemoryAgentPublicConfig;
 };
 
+const parsePreferredList = (value?: string) =>
+  value
+    ?.split(',')
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean);
+
 export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig => {
   const agentGateKeeper = parseGateKeeperAgent();
   const agentLayerExtractor = parseLayerExtractorAgent(agentGateKeeper.model);
@@ -167,8 +179,8 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
   );
   const extractorObservabilityS3 = parseExtractorAgentObservabilityS3();
   const featureFlags = {
-    enableBenchmarkLoCoMo: process.env.MEMORY_USER_MEMORY_FEATURE_FLAG_BENCHMARK_LOCOMO === 'true'
-  }
+    enableBenchmarkLoCoMo: process.env.MEMORY_USER_MEMORY_FEATURE_FLAG_BENCHMARK_LOCOMO === 'true',
+  };
   const concurrencyRaw = process.env.MEMORY_USER_MEMORY_CONCURRENCY;
   const concurrency =
     concurrencyRaw !== undefined
@@ -191,7 +203,9 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
       return acc;
     }, {});
 
-  const upstashWorkflowExtraHeaders = process.env.MEMORY_USER_MEMORY_WORKFLOW_EXTRA_HEADERS?.split(',')
+  const upstashWorkflowExtraHeaders = process.env.MEMORY_USER_MEMORY_WORKFLOW_EXTRA_HEADERS?.split(
+    ',',
+  )
     .filter(Boolean)
     .reduce<Record<string, string>>((acc, pair) => {
       const [key, value] = pair.split('=').map((s) => s.trim());
@@ -201,11 +215,36 @@ export const parseMemoryExtractionConfig = (): MemoryExtractionPrivateConfig =>
       return acc;
     }, {});
 
+  const agentGateKeeperPreferredProviders = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_GATEKEEPER_PREFERRED_PROVIDERS,
+  );
+  const agentGateKeeperPreferredModels = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_GATEKEEPER_PREFERRED_MODELS,
+  );
+  const embeddingPreferredProviders = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_EMBEDDING_PREFERRED_PROVIDERS,
+  );
+  const embeddingPreferredModels = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_EMBEDDING_PREFERRED_MODELS,
+  );
+  const agentLayerExtractorPreferredProviders = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_PREFERRED_PROVIDERS,
+  );
+  const agentLayerExtractorPreferredModels = parsePreferredList(
+    process.env.MEMORY_USER_MEMORY_LAYER_EXTRACTOR_PREFERRED_MODELS,
+  );
+
   return {
     agentGateKeeper,
+    agentGateKeeperPreferredModels,
+    agentGateKeeperPreferredProviders,
     agentLayerExtractor,
+    agentLayerExtractorPreferredModels,
+    agentLayerExtractorPreferredProviders,
     concurrency,
     embedding,
+    embeddingPreferredModels,
+    embeddingPreferredProviders,
     featureFlags,
     observabilityS3: extractorObservabilityS3,
     upstashWorkflowExtraHeaders,

package/src/server/services/memory/userMemory/__tests__/extract.payload.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest';
+
+import { LayersEnum, MemorySourceType } from '@/types/userMemory';
+
+import {
+  type MemoryExtractionNormalizedPayload,
+  type MemoryExtractionPayloadInput,
+  buildWorkflowPayloadInput,
+  normalizeMemoryExtractionPayload,
+} from '../extract';
+
+describe('normalizeMemoryExtractionPayload', () => {
+  it('normalizes sources, layers, ids, and dates with fallback baseUrl', () => {
+    const fromDate = new Date('2024-01-01T00:00:00Z');
+    const toDate = new Date('2024-02-01T00:00:00Z');
+
+    const payload: MemoryExtractionPayloadInput = {
+      forceAll: true,
+      forceTopics: true,
+      fromDate,
+      identityCursor: 3,
+      layers: [LayersEnum.Context, LayersEnum.Identity, LayersEnum.Context],
+      mode: 'direct',
+      sourceIds: ['source-1', 'source-1', ''],
+      sources: ['chatTopics', 'benchmark_locomo', 'unknown'],
+      toDate,
+      topicIds: ['topic-1', 'topic-1', ''],
+      userId: 'user-a',
+      userIds: ['user-a', 'user-b', ''],
+    };
+
+    const normalized = normalizeMemoryExtractionPayload(payload, 'https://api.example.com');
+
+    expect(normalized.baseUrl).toBe('https://api.example.com');
+    expect(normalized.forceAll).toBe(true);
+    expect(normalized.forceTopics).toBe(true);
+    expect(normalized.from).toEqual(fromDate);
+    expect(normalized.to).toEqual(toDate);
+    expect(normalized.identityCursor).toBe(3);
+    expect(normalized.layers).toEqual([LayersEnum.Context, LayersEnum.Identity]);
+    expect(normalized.sources).toEqual([
+      MemorySourceType.ChatTopic,
+      MemorySourceType.BenchmarkLocomo,
+    ]);
+    expect(normalized.sourceIds).toEqual(['source-1']);
+    expect(normalized.topicIds).toEqual(['topic-1']);
+    expect(normalized.userId).toBe('user-a');
+    expect(normalized.userIds).toEqual(['user-a', 'user-b']);
+  });
+
+  it('throws when baseUrl is missing in both payload and fallback', () => {
+    const payload: MemoryExtractionPayloadInput = {
+      forceAll: false,
+      forceTopics: false,
+      userIds: [],
+    };
+
+    expect(() => normalizeMemoryExtractionPayload(payload)).toThrow('Missing baseUrl');
+  });
+});
+
+describe('buildWorkflowPayloadInput', () => {
+  const baseNormalized: MemoryExtractionNormalizedPayload = {
+    baseUrl: 'https://api.example.com',
+    forceAll: false,
+    forceTopics: false,
+    from: undefined,
+    identityCursor: 0,
+    layers: [],
+    mode: 'workflow',
+    sourceIds: [],
+    sources: [MemorySourceType.ChatTopic],
+    to: undefined,
+    topicCursor: undefined,
+    topicIds: [],
+    userCursor: undefined,
+    userId: undefined,
+    userIds: ['user-x', 'user-y'],
+  };
+
+  it('falls back to the first user id when userId is missing', () => {
+    const payload = buildWorkflowPayloadInput(baseNormalized);
+
+    expect(payload.userId).toBe('user-x');
+    expect(payload.userIds).toEqual(['user-x', 'user-y']);
+    expect(payload.baseUrl).toBe('https://api.example.com');
+    expect(payload.mode).toBe('workflow');
+  });
+
+  it('preserves explicit userId when provided', () => {
+    const normalized: MemoryExtractionNormalizedPayload = {
+      ...baseNormalized,
+      userId: 'user-z',
+    };
+
+    const payload = buildWorkflowPayloadInput(normalized);
+
+    expect(payload.userId).toBe('user-z');
+    expect(payload.userIds).toEqual(['user-x', 'user-y']);
+  });
+});

package/src/server/services/memory/userMemory/__tests__/extract.runtime.test.ts

@@ -0,0 +1,121 @@
+import type { AiProviderRuntimeState } from '@lobechat/types';
+import type { EnabledAiModel } from 'model-bank';
+import { describe, expect, it } from 'vitest';
+
+import type { MemoryExtractionPrivateConfig } from '@/server/globalConfig/parseMemoryExtractionConfig';
+
+import { MemoryExtractionExecutor } from '../extract';
+
+const createRuntimeState = (models: EnabledAiModel[], keyVaults: Record<string, any>) =>
+  ({
+    enabledAiModels: models,
+    enabledAiProviders: [],
+    enabledChatAiProviders: [],
+    enabledImageAiProviders: [],
+    runtimeConfig: Object.fromEntries(
+      Object.entries(keyVaults).map(([providerId, vault]) => [
+        providerId,
+        { config: {}, keyVaults: vault, settings: {} },
+      ]),
+    ),
+  }) as AiProviderRuntimeState;
+
+const createExecutor = (privateOverrides?: Partial<MemoryExtractionPrivateConfig>) => {
+  const basePrivateConfig: MemoryExtractionPrivateConfig = {
+    agentGateKeeper: { model: 'gate-2', provider: 'provider-b' },
+    agentLayerExtractor: {
+      contextLimit: 2048,
+      layers: {
+        context: 'layer-ctx',
+        experience: 'layer-exp',
+        identity: 'layer-id',
+        preference: 'layer-pref',
+      },
+      model: 'layer-1',
+      provider: 'provider-l',
+    },
+    concurrency: 1,
+    embedding: { model: 'embed-1', provider: 'provider-e' },
+    featureFlags: { enableBenchmarkLoCoMo: false },
+    observabilityS3: { enabled: false },
+  };
+
+  const serverConfig = {
+    aiProvider: {},
+    memory: {},
+  };
+
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore accessing private constructor for testing
+  return new MemoryExtractionExecutor(serverConfig as any, {
+    ...basePrivateConfig,
+    ...privateOverrides,
+  });
+};
+
+describe('MemoryExtractionExecutor.resolveRuntimeKeyVaults', () => {
+  it('prefers configured providers/models for gatekeeper, embedding, and layer extractors', () => {
+    const executor = createExecutor({
+      embeddingPreferredProviders: ['provider-e'],
+      agentGateKeeperPreferredModels: ['gate-1'],
+      agentGateKeeperPreferredProviders: ['provider-a', 'provider-b'],
+      agentLayerExtractorPreferredProviders: ['provider-l'],
+    });
+
+    const runtimeState = createRuntimeState(
+      [
+        { abilities: {}, id: 'gate-1', providerId: 'provider-a', type: 'chat' },
+        { abilities: {}, id: 'gate-2', providerId: 'provider-b', type: 'chat' },
+        { abilities: {}, id: 'embed-1', providerId: 'provider-e', type: 'embedding' },
+        { abilities: {}, id: 'layer-ctx', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-exp', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-id', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-pref', providerId: 'provider-l', type: 'chat' },
+      ],
+      {
+        'provider-a': { apiKey: 'a-key' },
+        'provider-b': { apiKey: 'b-key' },
+        'provider-e': { apiKey: 'e-key' },
+        'provider-l': { apiKey: 'l-key' },
+      },
+    );
+
+    const keyVaults = (executor as any).resolveRuntimeKeyVaults(runtimeState);
+
+    expect(keyVaults).toMatchObject({
+      'provider-a': { apiKey: 'a-key' }, // gatekeeper picked preferred provider/model
+      'provider-e': { apiKey: 'e-key' }, // embedding honored preferred provider
+      'provider-l': { apiKey: 'l-key' }, // layer extractor models resolved
+    });
+  });
+
+  it('warns and falls back to server provider when no enabled provider satisfies embedding model', () => {
+    const executor = createExecutor();
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const runtimeState = createRuntimeState(
+      [
+        { abilities: {}, id: 'gate-2', providerId: 'provider-b', type: 'chat' },
+        { abilities: {}, id: 'layer-ctx', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-exp', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-id', providerId: 'provider-l', type: 'chat' },
+        { abilities: {}, id: 'layer-pref', providerId: 'provider-l', type: 'chat' },
+      ],
+      {
+        'provider-b': { apiKey: 'b-key' },
+        'provider-l': { apiKey: 'l-key' },
+      },
+    );
+
+    const keyVaults = (executor as any).resolveRuntimeKeyVaults(runtimeState);
+
+    expect(keyVaults).toMatchObject({
+      'provider-b': { apiKey: 'b-key' },
+      'provider-l': { apiKey: 'l-key' },
+    });
+    expect(keyVaults).not.toHaveProperty('provider-e');
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+});