@lobehub/lobehub 2.0.0-next.240 → 2.0.0-next.242

package/src/server/services/memory/userMemory/extract.ts

@@ -66,6 +66,7 @@ import type { GlobalMemoryLayer } from '@/types/serverConfig';
 import type { UserKeyVaults } from '@/types/user/settings';
 import { LayersEnum, type MergeStrategyEnum, TypesEnum, MemorySourceType } from '@/types/userMemory';
 import { encodeAsync } from '@/utils/tokenizer';
+import debug from 'debug';
 
 const SOURCE_ALIAS_MAP: Record<string, MemorySourceType> = {
   benchmark_locomo: MemorySourceType.BenchmarkLocomo,
@@ -262,19 +263,58 @@ const resolveLayerModels = (
   preference: layers?.preference ?? fallback.preference,
 });
 
-const initRuntimeForAgent = async (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
+const maskSecret = (value?: string) => {
+  if (!value) return 'undefined';
+  if (value.length <= 8) return `${value[0]}***${value.at(-1)}`;
+
+  return `${value.slice(0, 6)}***${value.slice(-4)}`;
+};
+
+const resolveRuntimeAgentConfig = (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
   const provider = agent.provider || 'openai';
   const { apiKey: userApiKey, baseURL: userBaseURL } = extractCredentialsFromVault(
     provider,
     keyVaults,
   );
 
-  const apiKey = userApiKey || agent.apiKey;
-  if (!apiKey) throw new Error(`Missing API key for ${provider} memory extraction runtime`);
+  // Only use the user baseURL if we are also using their API key; otherwise fall back entirely
+  // to system config to avoid mixing credentials.
+  const useUserCredential = !!userApiKey;
+  const apiKey = useUserCredential ? userApiKey : agent.apiKey;
+  const baseURL = useUserCredential ? userBaseURL || agent.baseURL : agent.baseURL;
+  const source = useUserCredential ? 'user-keyvault' : 'system-config';
+
+  return { apiKey, baseURL, provider, source };
+};
+
+const logRuntime = debug('lobe-server:memory:user-memory:runtime');
+
+const debugRuntimeInit = (
+  agent: MemoryAgentConfig,
+  resolved: ReturnType<typeof resolveRuntimeAgentConfig>,
+) => {
+  if (!logRuntime.enabled) return;
+  logRuntime('init runtime', {
+    agentModel: agent.model,
+    agentProvider: agent.provider || 'openai',
+    apiKey: maskSecret(resolved.apiKey),
+    baseURL: resolved.baseURL,
+    provider: resolved.provider,
+    source: resolved.source,
+  });
+};
+
+const initRuntimeForAgent = async (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
+  const resolved = resolveRuntimeAgentConfig(agent, keyVaults);
+  debugRuntimeInit(agent, resolved);
+
+  if (!resolved.apiKey) {
+    throw new Error(`Missing API key for ${resolved.provider} memory extraction runtime`);
+  }
 
-  return ModelRuntime.initializeWithProvider(provider, {
-    apiKey,
-    baseURL: userBaseURL || agent.baseURL,
+  return ModelRuntime.initializeWithProvider(resolved.provider, {
+    apiKey: resolved.apiKey,
+    baseURL: resolved.baseURL,
   });
 };
 

package/src/store/electron/actions/navigationHistory.ts

@@ -0,0 +1,247 @@
+import { type StateCreator } from 'zustand/vanilla';
+
+import type { ElectronStore } from '../store';
+
+// ======== Types ======== //
+
+export interface HistoryEntry {
+  icon?: string;
+  metadata?: {
+    [key: string]: any;
+    sessionId?: string;
+    timestamp: number;
+  };
+  title: string;
+  url: string;
+}
+
+export interface NavigationHistoryState {
+  /**
+   * Current page title from PageTitle component
+   * Used to get dynamic titles without setTimeout hack
+   */
+  currentPageTitle: string;
+  /**
+   * Current position in history (-1 means empty)
+   */
+  historyCurrentIndex: number;
+  /**
+   * History entries list
+   */
+  historyEntries: HistoryEntry[];
+  /**
+   * Flag to indicate if currently navigating via back/forward
+   * Used to prevent adding duplicate history entries
+   */
+  isNavigatingHistory: boolean;
+}
+
+// ======== Action Interface ======== //
+
+export interface NavigationHistoryAction {
+  /**
+   * Check if can go back in history
+   */
+  canGoBack: () => boolean;
+
+  /**
+   * Check if can go forward in history
+   */
+  canGoForward: () => boolean;
+
+  /**
+   * Get current history entry
+   */
+  getCurrentEntry: () => HistoryEntry | null;
+
+  /**
+   * Navigate back in history
+   * @returns The target entry or null if cannot go back
+   */
+  goBack: () => HistoryEntry | null;
+
+  /**
+   * Navigate forward in history
+   * @returns The target entry or null if cannot go forward
+   */
+  goForward: () => HistoryEntry | null;
+
+  /**
+   * Push a new entry to history (for normal navigation)
+   * Truncates any forward history if not at the end
+   */
+  pushHistory: (
+    entry: Omit<HistoryEntry, 'metadata'> & { metadata?: Partial<HistoryEntry['metadata']> },
+  ) => void;
+
+  /**
+   * Replace current entry in history (for replace navigation)
+   */
+  replaceHistory: (
+    entry: Omit<HistoryEntry, 'metadata'> & { metadata?: Partial<HistoryEntry['metadata']> },
+  ) => void;
+
+  /**
+   * Set current page title (called by PageTitle component)
+   */
+  setCurrentPageTitle: (title: string) => void;
+
+  /**
+   * Set the navigating history flag
+   */
+  setIsNavigatingHistory: (value: boolean) => void;
+}
+
+// ======== Initial State ======== //
+
+export const navigationHistoryInitialState: NavigationHistoryState = {
+  currentPageTitle: '',
+  historyCurrentIndex: -1,
+  historyEntries: [],
+  isNavigatingHistory: false,
+};
+
+// ======== Action Implementation ======== //
+
+export const createNavigationHistorySlice: StateCreator<
+  ElectronStore,
+  [['zustand/devtools', never]],
+  [],
+  NavigationHistoryAction
+> = (set, get) => ({
+  canGoBack: () => {
+    const { historyCurrentIndex } = get();
+    return historyCurrentIndex > 0;
+  },
+
+  canGoForward: () => {
+    const { historyCurrentIndex, historyEntries } = get();
+    return historyCurrentIndex < historyEntries.length - 1;
+  },
+
+  getCurrentEntry: () => {
+    const { historyCurrentIndex, historyEntries } = get();
+    if (historyCurrentIndex < 0 || historyCurrentIndex >= historyEntries.length) {
+      return null;
+    }
+    return historyEntries[historyCurrentIndex];
+  },
+
+  goBack: () => {
+    const { historyCurrentIndex, historyEntries } = get();
+
+    if (historyCurrentIndex <= 0) {
+      return null;
+    }
+
+    const newIndex = historyCurrentIndex - 1;
+    const targetEntry = historyEntries[newIndex];
+
+    set(
+      {
+        historyCurrentIndex: newIndex,
+        isNavigatingHistory: true,
+      },
+      false,
+      'goBack',
+    );
+
+    return targetEntry;
+  },
+
+  goForward: () => {
+    const { historyCurrentIndex, historyEntries } = get();
+
+    if (historyCurrentIndex >= historyEntries.length - 1) {
+      return null;
+    }
+
+    const newIndex = historyCurrentIndex + 1;
+    const targetEntry = historyEntries[newIndex];
+
+    set(
+      {
+        historyCurrentIndex: newIndex,
+        isNavigatingHistory: true,
+      },
+      false,
+      'goForward',
+    );
+
+    return targetEntry;
+  },
+
+  pushHistory: (entry) => {
+    const { historyCurrentIndex, historyEntries } = get();
+
+    // Create full entry with metadata
+    const fullEntry: HistoryEntry = {
+      icon: entry.icon,
+      metadata: {
+        timestamp: Date.now(),
+        ...entry.metadata,
+      },
+      title: entry.title,
+      url: entry.url,
+    };
+
+    // If not at the end, truncate forward history
+    const newEntries =
+      historyCurrentIndex < historyEntries.length - 1
+        ? historyEntries.slice(0, historyCurrentIndex + 1)
+        : [...historyEntries];
+
+    // Add new entry
+    newEntries.push(fullEntry);
+
+    set(
+      {
+        historyCurrentIndex: newEntries.length - 1,
+        historyEntries: newEntries,
+      },
+      false,
+      'pushHistory',
+    );
+  },
+
+  replaceHistory: (entry) => {
+    const { historyCurrentIndex, historyEntries } = get();
+
+    // If history is empty, just push
+    if (historyCurrentIndex < 0 || historyEntries.length === 0) {
+      get().pushHistory(entry);
+      return;
+    }
+
+    // Create full entry with metadata
+    const fullEntry: HistoryEntry = {
+      icon: entry.icon,
+      metadata: {
+        timestamp: Date.now(),
+        ...entry.metadata,
+      },
+      title: entry.title,
+      url: entry.url,
+    };
+
+    // Replace current entry
+    const newEntries = [...historyEntries];
+    newEntries[historyCurrentIndex] = fullEntry;
+
+    set(
+      {
+        historyEntries: newEntries,
+      },
+      false,
+      'replaceHistory',
+    );
+  },
+
+  setCurrentPageTitle: (title) => {
+    set({ currentPageTitle: title }, false, 'setCurrentPageTitle');
+  },
+
+  setIsNavigatingHistory: (value) => {
+    set({ isNavigatingHistory: value }, false, 'setIsNavigatingHistory');
+  },
+});

package/src/store/electron/initialState.ts

@@ -4,6 +4,11 @@ import {
   type NetworkProxySettings,
 } from '@lobechat/electron-client-ipc';
 
+import {
+  type NavigationHistoryState,
+  navigationHistoryInitialState,
+} from './actions/navigationHistory';
+
 export type RemoteServerError = 'CONFIG_ERROR' | 'AUTH_ERROR' | 'DISCONNECT_ERROR';
 
 export const defaultProxySettings: NetworkProxySettings = {
@@ -15,7 +20,7 @@ export const defaultProxySettings: NetworkProxySettings = {
   proxyType: 'http',
 };
 
-export interface ElectronState {
+export interface ElectronState extends NavigationHistoryState {
   appState: ElectronAppState;
   dataSyncConfig: DataSyncConfig;
   desktopHotkeys: Record<string, string>;
@@ -29,6 +34,7 @@ export interface ElectronState {
 }
 
 export const initialState: ElectronState = {
+  ...navigationHistoryInitialState,
   appState: {},
   dataSyncConfig: { storageMode: 'cloud' },
   desktopHotkeys: {},

package/src/store/electron/store.ts

@@ -4,6 +4,10 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
 import { type ElectronAppAction, createElectronAppSlice } from './actions/app';
+import {
+  type NavigationHistoryAction,
+  createNavigationHistorySlice,
+} from './actions/navigationHistory';
 import { type ElectronSettingsAction, settingsSlice } from './actions/settings';
 import { type ElectronRemoteServerAction, remoteSyncSlice } from './actions/sync';
 import { type ElectronState, initialState } from './initialState';
@@ -11,10 +15,12 @@ import { type ElectronState, initialState } from './initialState';
 //  ===============  Aggregate createStoreFn ============ //
 
 export interface ElectronStore
-  extends ElectronState,
+  extends
+    ElectronState,
     ElectronRemoteServerAction,
     ElectronAppAction,
-    ElectronSettingsAction {
+    ElectronSettingsAction,
+    NavigationHistoryAction {
   /* empty */
 }
 
@@ -25,6 +31,7 @@ const createStore: StateCreator<ElectronStore, [['zustand/devtools', never]]> =
   ...remoteSyncSlice(...parameters),
   ...createElectronAppSlice(...parameters),
   ...settingsSlice(...parameters),
+  ...createNavigationHistorySlice(...parameters),
 });
 
 //  ===============  Implement useStore ============ //

package/src/store/global/selectors/systemStatus.ts

@@ -30,7 +30,10 @@ const modelSwitchPanelWidth = (s: GlobalState) => s.status.modelSwitchPanelWidth
 
 const showChatHeader = (s: GlobalState) => !s.status.zenMode;
 const inZenMode = (s: GlobalState) => s.status.zenMode;
-const leftPanelWidth = (s: GlobalState) => s.status.leftPanelWidth;
+const leftPanelWidth = (s: GlobalState): number => {
+  const width = s.status.leftPanelWidth;
+  return typeof width === 'string' ? Number.parseInt(width) : width;
+};
 const portalWidth = (s: GlobalState) => s.status.portalWidth || 400;
 const filePanelWidth = (s: GlobalState) => s.status.filePanelWidth;
 const imagePanelWidth = (s: GlobalState) => s.status.imagePanelWidth;