@lobehub/chat 1.133.5 → 1.134.0

package/src/config/featureFlags/schema.ts

@@ -1,51 +1,71 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix */
 import { z } from 'zod';
 
+// Define a union type for feature flag values: either boolean or array of user IDs
+const FeatureFlagValue = z.union([z.boolean(), z.array(z.string())]);
+
 export const FeatureFlagsSchema = z.object({
-  check_updates: z.boolean().optional(),
-  pin_list: z.boolean().optional(),
+  check_updates: FeatureFlagValue.optional(),
+  pin_list: FeatureFlagValue.optional(),
 
   // settings
-  language_model_settings: z.boolean().optional(),
-  provider_settings: z.boolean().optional(),
+  language_model_settings: FeatureFlagValue.optional(),
+  provider_settings: FeatureFlagValue.optional(),
 
-  openai_api_key: z.boolean().optional(),
-  openai_proxy_url: z.boolean().optional(),
+  openai_api_key: FeatureFlagValue.optional(),
+  openai_proxy_url: FeatureFlagValue.optional(),
 
   // profile
-  api_key_manage: z.boolean().optional(),
+  api_key_manage: FeatureFlagValue.optional(),
 
-  create_session: z.boolean().optional(),
-  edit_agent: z.boolean().optional(),
+  create_session: FeatureFlagValue.optional(),
+  edit_agent: FeatureFlagValue.optional(),
 
-  plugins: z.boolean().optional(),
-  dalle: z.boolean().optional(),
-  ai_image: z.boolean().optional(),
-  speech_to_text: z.boolean().optional(),
-  token_counter: z.boolean().optional(),
+  plugins: FeatureFlagValue.optional(),
+  dalle: FeatureFlagValue.optional(),
+  ai_image: FeatureFlagValue.optional(),
+  speech_to_text: FeatureFlagValue.optional(),
+  token_counter: FeatureFlagValue.optional(),
 
-  welcome_suggest: z.boolean().optional(),
-  changelog: z.boolean().optional(),
+  welcome_suggest: FeatureFlagValue.optional(),
+  changelog: FeatureFlagValue.optional(),
 
-  clerk_sign_up: z.boolean().optional(),
+  clerk_sign_up: FeatureFlagValue.optional(),
 
-  market: z.boolean().optional(),
-  knowledge_base: z.boolean().optional(),
+  market: FeatureFlagValue.optional(),
+  knowledge_base: FeatureFlagValue.optional(),
 
-  rag_eval: z.boolean().optional(),
+  rag_eval: FeatureFlagValue.optional(),
 
   // internal flag
-  cloud_promotion: z.boolean().optional(),
+  cloud_promotion: FeatureFlagValue.optional(),
 
   // the flags below can only be used with commercial license
   // if you want to use it in the commercial usage
   // please contact us for more information: hello@lobehub.com
-  commercial_hide_github: z.boolean().optional(),
-  commercial_hide_docs: z.boolean().optional(),
+  commercial_hide_github: FeatureFlagValue.optional(),
+  commercial_hide_docs: FeatureFlagValue.optional(),
 });
 
 export type IFeatureFlags = z.infer<typeof FeatureFlagsSchema>;
 
+/**
+ * Evaluate a feature flag value against a user ID
+ * @param flagValue - The feature flag value (boolean or array of user IDs)
+ * @param userId - The current user ID
+ * @returns boolean indicating if the feature is enabled for the user
+ */
+export const evaluateFeatureFlag = (
+  flagValue: boolean | string[] | undefined,
+  userId?: string,
+): boolean | undefined => {
+  if (typeof flagValue === 'boolean') return flagValue;
+
+  if (Array.isArray(flagValue)) {
+    return userId ? flagValue.includes(userId) : false;
+  }
+};
+
 export const DEFAULT_FEATURE_FLAGS: IFeatureFlags = {
   pin_list: false,
 
@@ -86,39 +106,41 @@ export const DEFAULT_FEATURE_FLAGS: IFeatureFlags = {
   commercial_hide_docs: false,
 };
 
-export const mapFeatureFlagsEnvToState = (config: IFeatureFlags) => {
+export const mapFeatureFlagsEnvToState = (config: IFeatureFlags, userId?: string) => {
   return {
-    isAgentEditable: config.edit_agent,
+    isAgentEditable: evaluateFeatureFlag(config.edit_agent, userId),
 
-    showCreateSession: config.create_session,
-    showLLM: config.language_model_settings,
-    showProvider: config.provider_settings,
-    showPinList: config.pin_list,
+    showCreateSession: evaluateFeatureFlag(config.create_session, userId),
+    showLLM: evaluateFeatureFlag(config.language_model_settings, userId),
+    showProvider: evaluateFeatureFlag(config.provider_settings, userId),
+    showPinList: evaluateFeatureFlag(config.pin_list, userId),
 
-    showOpenAIApiKey: config.openai_api_key,
-    showOpenAIProxyUrl: config.openai_proxy_url,
+    showOpenAIApiKey: evaluateFeatureFlag(config.openai_api_key, userId),
+    showOpenAIProxyUrl: evaluateFeatureFlag(config.openai_proxy_url, userId),
 
-    showApiKeyManage: config.api_key_manage,
+    showApiKeyManage: evaluateFeatureFlag(config.api_key_manage, userId),
 
-    enablePlugins: config.plugins,
-    showDalle: config.dalle,
-    showAiImage: config.ai_image,
-    showChangelog: config.changelog,
+    enablePlugins: evaluateFeatureFlag(config.plugins, userId),
+    showDalle: evaluateFeatureFlag(config.dalle, userId),
+    showAiImage: evaluateFeatureFlag(config.ai_image, userId),
+    showChangelog: evaluateFeatureFlag(config.changelog, userId),
 
-    enableCheckUpdates: config.check_updates,
-    showWelcomeSuggest: config.welcome_suggest,
+    enableCheckUpdates: evaluateFeatureFlag(config.check_updates, userId),
+    showWelcomeSuggest: evaluateFeatureFlag(config.welcome_suggest, userId),
 
-    enableClerkSignUp: config.clerk_sign_up,
+    enableClerkSignUp: evaluateFeatureFlag(config.clerk_sign_up, userId),
 
-    enableKnowledgeBase: config.knowledge_base,
-    enableRAGEval: config.rag_eval,
+    enableKnowledgeBase: evaluateFeatureFlag(config.knowledge_base, userId),
+    enableRAGEval: evaluateFeatureFlag(config.rag_eval, userId),
 
-    showCloudPromotion: config.cloud_promotion,
+    showCloudPromotion: evaluateFeatureFlag(config.cloud_promotion, userId),
 
-    showMarket: config.market,
-    enableSTT: config.speech_to_text,
+    showMarket: evaluateFeatureFlag(config.market, userId),
+    enableSTT: evaluateFeatureFlag(config.speech_to_text, userId),
 
-    hideGitHub: config.commercial_hide_github,
-    hideDocs: config.commercial_hide_docs,
+    hideGitHub: evaluateFeatureFlag(config.commercial_hide_github, userId),
+    hideDocs: evaluateFeatureFlag(config.commercial_hide_docs, userId),
   };
 };
+
+export type IFeatureFlagsState = ReturnType<typeof mapFeatureFlagsEnvToState>;

package/src/features/ElectronTitlebar/Connection/index.tsx

@@ -20,7 +20,6 @@ const useStyles = createStyles(({ css }) => {
 
 const Connection = () => {
   const { styles, theme } = useStyles();
-
   const [isOpen, setIsOpen] = useState(false);
   const [isWaiting, setWaiting] = useState(false);
 

package/src/hooks/useIsSingleMode.test.ts

@@ -0,0 +1,66 @@
+import { renderHook } from '@testing-library/react';
+import { ReadonlyURLSearchParams } from 'next/navigation';
+import { describe, expect, it, vi } from 'vitest';
+
+import { useIsSingleMode } from './useIsSingleMode';
+
+// Mock next/navigation
+const mockUseSearchParams = vi.hoisted(() => vi.fn());
+vi.mock('next/navigation', () => ({
+  useSearchParams: mockUseSearchParams,
+}));
+
+describe('useIsSingleMode', () => {
+
+  it('should return false initially (during SSR)', () => {
+    const mockSearchParams = {
+      get: vi.fn(() => 'single'),
+    } as unknown as ReadonlyURLSearchParams;
+
+    mockUseSearchParams.mockReturnValue(mockSearchParams);
+
+    const { result } = renderHook(() => useIsSingleMode());
+
+    // In test environment, useEffect runs synchronously, so it will immediately detect single mode
+    expect(result.current).toBe(true);
+  });
+
+  it('should return true when mode=single', () => {
+    const mockSearchParams = {
+      get: vi.fn((key: string) => (key === 'mode' ? 'single' : null)),
+    } as unknown as ReadonlyURLSearchParams;
+
+    mockUseSearchParams.mockReturnValue(mockSearchParams);
+
+    const { result } = renderHook(() => useIsSingleMode());
+
+    // Should immediately detect single mode in test environment
+    expect(result.current).toBe(true);
+  });
+
+  it('should return false when mode is not single', () => {
+    const mockSearchParams = {
+      get: vi.fn((key: string) => (key === 'mode' ? 'normal' : null)),
+    } as unknown as ReadonlyURLSearchParams;
+
+    mockUseSearchParams.mockReturnValue(mockSearchParams);
+
+    const { result } = renderHook(() => useIsSingleMode());
+
+    // Should return false for non-single mode
+    expect(result.current).toBe(false);
+  });
+
+  it('should return false when no mode parameter exists', () => {
+    const mockSearchParams = {
+      get: vi.fn(() => null),
+    } as unknown as ReadonlyURLSearchParams;
+
+    mockUseSearchParams.mockReturnValue(mockSearchParams);
+
+    const { result } = renderHook(() => useIsSingleMode());
+
+    // Should return false when no mode parameter
+    expect(result.current).toBe(false);
+  });
+});

package/src/hooks/useIsSingleMode.ts

@@ -0,0 +1,29 @@
+'use client';
+
+import { useSearchParams } from 'next/navigation';
+import { useEffect, useState } from 'react';
+
+/**
+ * Hook to check if the current page is in single mode
+ * Single mode is used for standalone windows in desktop app
+ * @returns boolean indicating if the current page is in single mode
+ */
+export const useIsSingleMode = (): boolean => {
+  const [isSingleMode, setIsSingleMode] = useState(false);
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  const searchParams = useSearchParams();
+
+  useEffect(() => {
+    if (mounted) {
+      setIsSingleMode(searchParams.get('mode') === 'single');
+    }
+  }, [searchParams, mounted]);
+
+  // Return false during SSR or before hydration
+  return mounted ? isSingleMode : false;
+};

package/src/server/featureFlags/index.ts

@@ -0,0 +1,56 @@
+import createDebug from 'debug';
+
+import {
+  DEFAULT_FEATURE_FLAGS,
+  getServerFeatureFlagsValue,
+  mapFeatureFlagsEnvToState,
+} from '@/config/featureFlags';
+import { merge } from '@/utils/merge';
+
+import { EdgeConfig } from '../modules/EdgeConfig';
+
+const debug = createDebug('lobe:featureFlags');
+
+/**
+ * Get feature flags from EdgeConfig with fallback to environment variables
+ * @param userId - Optional user ID for user-specific feature flag evaluation
+ */
+export const getServerFeatureFlagsFromEdgeConfig = async (userId?: string) => {
+  // Try to get feature flags from EdgeConfig first
+  if (EdgeConfig.isEnabled()) {
+    try {
+      const edgeConfig = new EdgeConfig();
+      const edgeFeatureFlags = await edgeConfig.getFeatureFlags();
+
+      if (edgeFeatureFlags && Object.keys(edgeFeatureFlags).length > 0) {
+        // Merge EdgeConfig flags with defaults
+        const mergedFlags = merge(DEFAULT_FEATURE_FLAGS, edgeFeatureFlags);
+        debug('Using EdgeConfig flags for user: %s', userId || 'anonymous');
+        return mergedFlags;
+      } else {
+        debug('EdgeConfig returned empty/null/undefined, falling back to environment variables');
+      }
+    } catch (error) {
+      console.error(
+        '[FeatureFlags] Failed to fetch feature flags from EdgeConfig, falling back to environment variables:',
+        error,
+      );
+    }
+  } else {
+    debug('EdgeConfig not enabled, using environment variables');
+  }
+
+  // Fallback to environment variable-based feature flags
+  const envFlags = getServerFeatureFlagsValue();
+  debug('Using environment variable flags for user: %s', userId || 'anonymous');
+  return envFlags;
+};
+
+/**
+ * Get server feature flags from EdgeConfig and map them to state with user ID
+ * @param userId - Optional user ID for user-specific feature flag evaluation
+ */
+export const getServerFeatureFlagsStateFromEdgeConfig = async (userId?: string) => {
+  const flags = await getServerFeatureFlagsFromEdgeConfig(userId);
+  return mapFeatureFlagsEnvToState(flags, userId);
+};

package/src/server/modules/EdgeConfig/index.ts

@@ -1,8 +1,24 @@
 import { EdgeConfigClient, createClient } from '@vercel/edge-config';
+import createDebug from 'debug';
 
 import { appEnv } from '@/envs/app';
 
-import type { EdgeConfigData } from './types';
+const debug = createDebug('lobe-server:edge-config');
+
+const EdgeConfigKeys = {
+  /**
+   * Assistant whitelist
+   */
+  AssistantBlacklist: 'assistant_blacklist',
+  /**
+   * Assistant whitelist
+   */
+  AssistantWhitelist: 'assistant_whitelist',
+  /**
+   * Feature flags configuration
+   */
+  FeatureFlags: 'feature_flags',
+};
 
 export class EdgeConfig {
   get client(): EdgeConfigClient {
@@ -16,12 +32,35 @@ export class EdgeConfig {
    * Check if Edge Config is enabled
    */
   static isEnabled() {
-    return !!appEnv.VERCEL_EDGE_CONFIG;
+    const isEnabled = !!appEnv.VERCEL_EDGE_CONFIG;
+    debug('VERCEL_EDGE_CONFIG env var: %s', appEnv.VERCEL_EDGE_CONFIG ? 'SET' : 'NOT SET');
+    debug('EdgeConfig enabled: %s', isEnabled);
+    return isEnabled;
   }
 
   getAgentRestrictions = async () => {
     const { assistant_blacklist: blacklist, assistant_whitelist: whitelist } =
-      await this.client.getAll<EdgeConfigData>(['assistant_whitelist', 'assistant_blacklist']);
-    return { blacklist, whitelist };
+      await this.client.getAll([
+        EdgeConfigKeys.AssistantWhitelist,
+        EdgeConfigKeys.AssistantBlacklist,
+      ]);
+
+    return { blacklist, whitelist } as {
+      blacklist: string[] | undefined;
+      whitelist: string[] | undefined;
+    };
+  };
+
+  getFlagByKey = async (key: string) => {
+    const value = await this.client.get(key);
+    return value;
+  };
+
+  getFeatureFlags = async () => {
+    const featureFlags = await this.client.get(EdgeConfigKeys.FeatureFlags);
+    debug('Feature flags retrieved: %O', featureFlags);
+    return featureFlags as Record<string, boolean | string[]> | undefined;
   };
 }
+
+export { EdgeConfigKeys };

package/src/server/routers/lambda/aiModel.test.ts

@@ -151,12 +151,14 @@ describe('aiModelRouter', () => {
       id: 'model-1',
       providerId: 'provider-1',
       enabled: true,
+      type: 'embedding',
     });
 
     expect(mockToggle).toHaveBeenCalledWith({
       id: 'model-1',
       providerId: 'provider-1',
       enabled: true,
+      type: 'embedding',
     });
   });
 

package/src/store/global/actions/general.ts

@@ -20,6 +20,8 @@ import type { GlobalStore } from '../store';
 const n = setNamespace('g');
 
 export interface GlobalGeneralAction {
+  openSessionInNewWindow: (sessionId: string) => Promise<void>;
+  openTopicInNewWindow: (sessionId: string, topicId: string) => Promise<void>;
   switchLocale: (locale: LocaleMode) => void;
   switchThemeMode: (themeMode: ThemeMode, params?: { skipBroadcast?: boolean }) => void;
   updateSystemStatus: (status: Partial<SystemStatus>, action?: any) => void;
@@ -33,6 +35,50 @@ export const generalActionSlice: StateCreator<
   [],
   GlobalGeneralAction
 > = (set, get) => ({
+  openSessionInNewWindow: async (sessionId: string) => {
+    if (!isDesktop) return;
+
+    try {
+      const { dispatch } = await import('@lobechat/electron-client-ipc');
+
+      const url = `/chat?session=${sessionId}&mode=single`;
+
+      const result = await dispatch('createMultiInstanceWindow', {
+        path: url,
+        templateId: 'chatSingle',
+        uniqueId: `chat_${sessionId}`,
+      });
+
+      if (!result.success) {
+        console.error('Failed to open session in new window:', result.error);
+      }
+    } catch (error) {
+      console.error('Error opening session in new window:', error);
+    }
+  },
+
+  openTopicInNewWindow: async (sessionId: string, topicId: string) => {
+    if (!isDesktop) return;
+
+    try {
+      const { dispatch } = await import('@lobechat/electron-client-ipc');
+
+      const url = `/chat?session=${sessionId}&topic=${topicId}&mode=single`;
+
+      const result = await dispatch('createMultiInstanceWindow', {
+        path: url,
+        templateId: 'chatSingle',
+        uniqueId: `chat_${sessionId}_${topicId}`,
+      });
+
+      if (!result.success) {
+        console.error('Failed to open topic in new window:', result.error);
+      }
+    } catch (error) {
+      console.error('Error opening topic in new window:', error);
+    }
+  },
+
   switchLocale: (locale) => {
     get().updateSystemStatus({ language: locale });