@lobehub/lobehub 2.0.0-next.354 → 2.0.0-next.356

package/src/features/ChatInput/ChatInputProvider.tsx

@@ -1,5 +1,8 @@
 import { useEditor } from '@lobehub/editor/react';
-import { type ReactNode, memo, useRef } from 'react';
+import { type MutableRefObject, type ReactNode, memo, useRef } from 'react';
+
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/selectors';
 
 import StoreUpdater, { type StoreUpdaterProps } from './StoreUpdater';
 import { Provider, createStore } from './store';
@@ -8,10 +11,16 @@ interface ChatInputProviderProps extends StoreUpdaterProps {
   children: ReactNode;
 }
 
-export const ChatInputProvider = memo<ChatInputProviderProps>(
+interface ChatInputProviderInnerProps extends StoreUpdaterProps {
+  children: ReactNode;
+  contentRef: MutableRefObject<string>;
+}
+
+const ChatInputProviderInner = memo<ChatInputProviderInnerProps>(
   ({
     agentId,
     children,
+    contentRef,
     leftActions,
     rightActions,
     mobile,
@@ -31,6 +40,7 @@ export const ChatInputProvider = memo<ChatInputProviderProps>(
         createStore={() =>
           createStore({
             allowExpand,
+            contentRef,
             editor,
             leftActions,
             mentionItems,
@@ -60,3 +70,13 @@ export const ChatInputProvider = memo<ChatInputProviderProps>(
     );
   },
 );
+
+export const ChatInputProvider = (props: ChatInputProviderProps) => {
+  const enableRichRender = useUserStore(labPreferSelectors.enableInputMarkdown);
+  // Ref to persist content across re-mounts when enableRichRender changes
+  const contentRef = useRef<string>('');
+
+  return (
+    <ChatInputProviderInner contentRef={contentRef} key={`editor-${enableRichRender}`} {...props} />
+  );
+};

package/src/features/ChatInput/InputEditor/index.tsx

@@ -37,7 +37,7 @@ const className = cx(css`
 `);
 
 const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
-  const [editor, slashMenuRef, send, updateMarkdownContent, expand, mentionItems] =
+  const [editor, slashMenuRef, send, updateMarkdownContent, expand, mentionItems, contentRef] =
     useChatInputStore((s) => [
       s.editor,
       s.slashMenuRef,
@@ -45,6 +45,7 @@ const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
       s.updateMarkdownContent,
       s.expand,
       s.mentionItems,
+      s.contentRef,
     ]);
 
   const storeApi = useStoreApi();
@@ -151,7 +152,11 @@ const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
       onBlur={() => {
         disableScope(HotkeyEnum.AddUserMessage);
       }}
-      onChange={() => {
+      onChange={(e) => {
+        // Save content to parent ref for restoration when enableRichRender changes
+        if (contentRef) {
+          contentRef.current = e.getDocument('markdown') as unknown as string;
+        }
         updateMarkdownContent();
       }}
       onCompositionEnd={() => {
@@ -177,7 +182,13 @@ const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
       onFocus={() => {
         enableScope(HotkeyEnum.AddUserMessage);
       }}
-      onInit={(editor) => storeApi.setState({ editor })}
+      onInit={(editor) => {
+        storeApi.setState({ editor });
+        // Restore content from parent ref when editor re-initializes
+        if (contentRef?.current) {
+          editor.setDocument('markdown', contentRef.current);
+        }
+      }}
       onPressEnter={({ event: e }) => {
         if (e.shiftKey || isChineseInput.current) return;
         // when user like alt + enter to add ai message

package/src/features/ChatInput/store/initialState.ts

@@ -1,6 +1,7 @@
 import { type IEditor, type SlashOptions } from '@lobehub/editor';
 import type { ChatInputProps } from '@lobehub/editor/react';
 import type { MenuProps } from '@lobehub/ui';
+import type { MutableRefObject } from 'react';
 
 import { type ActionKeys } from '@/features/ChatInput';
 
@@ -39,6 +40,7 @@ export interface PublicState {
 }
 
 export interface State extends PublicState {
+  contentRef?: MutableRefObject<string>;
   editor?: IEditor;
   isContentEmpty: boolean;
   markdownContent: string;

package/src/features/User/__tests__/PanelContent.test.tsx

@@ -67,17 +67,6 @@ vi.mock('@/const/version', () => ({
   isDesktop: false,
 }));
 
-// Use vi.hoisted to ensure variables exist before vi.mock factory executes
-const { enableNextAuth } = vi.hoisted(() => ({
-  enableNextAuth: { value: false },
-}));
-
-vi.mock('@/envs/auth', () => ({
-  get enableNextAuth() {
-    return enableNextAuth.value;
-  },
-}));
-
 describe('PanelContent', () => {
   const closePopover = vi.fn();
 

package/src/features/User/__tests__/UserAvatar.test.tsx

@@ -1,6 +1,6 @@
 import { BRANDING_NAME } from '@lobechat/business-const';
 import { act, render, screen } from '@testing-library/react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { DEFAULT_USER_AVATAR_URL } from '@/const/meta';
 import { useUserStore } from '@/store/user';
@@ -9,21 +9,6 @@ import UserAvatar from '../UserAvatar';
 
 vi.mock('zustand/traditional');
 
-// Use vi.hoisted to ensure variables exist before vi.mock factory executes
-const { enableNextAuth } = vi.hoisted(() => ({
-  enableNextAuth: { value: false },
-}));
-
-vi.mock('@/envs/auth', () => ({
-  get enableNextAuth() {
-    return enableNextAuth.value;
-  },
-}));
-
-afterEach(() => {
-  enableNextAuth.value = false;
-});
-
 describe('UserAvatar', () => {
   it('should show the username and avatar are displayed when the user is logged in', async () => {
     const mockAvatar = 'https://example.com/avatar.png';

package/src/layout/AuthProvider/index.tsx

@@ -5,7 +5,6 @@ import { authEnv } from '@/envs/auth';
 
 import BetterAuth from './BetterAuth';
 import Desktop from './Desktop';
-import NextAuth from './NextAuth';
 import NoAuth from './NoAuth';
 
 const AuthProvider = ({ children }: PropsWithChildren) => {
@@ -13,14 +12,10 @@ const AuthProvider = ({ children }: PropsWithChildren) => {
     return <Desktop>{children}</Desktop>;
   }
 
-  if (authEnv.NEXT_PUBLIC_ENABLE_BETTER_AUTH) {
+  if (authEnv.AUTH_SECRET) {
     return <BetterAuth>{children}</BetterAuth>;
   }
 
-  if (authEnv.NEXT_PUBLIC_ENABLE_NEXT_AUTH) {
-    return <NextAuth>{children}</NextAuth>;
-  }
-
   return <NoAuth>{children}</NoAuth>;
 };
 

package/src/layout/GlobalProvider/StoreInitialization.tsx

@@ -6,7 +6,6 @@ import { useTranslation } from 'react-i18next';
 import { createStoreUpdater } from 'zustand-utils';
 
 import { isDesktop } from '@/const/version';
-import { enableNextAuth } from '@/envs/auth';
 import { useIsMobile } from '@/hooks/useIsMobile';
 import { useAgentStore } from '@/store/agent';
 import { useAiInfraStore } from '@/store/aiInfra';
@@ -25,9 +24,8 @@ const StoreInitialization = memo(() => {
   // prefetch error ns to avoid don't show error content correctly
   useTranslation('error');
 
-  const [isLogin, isSignedIn, useInitUserState] = useUserStore((s) => [
+  const [isLogin, useInitUserState] = useUserStore((s) => [
     authSelectors.isLogin(s),
-    s.isSignedIn,
     s.useInitUserState,
   ]);
 
@@ -65,7 +63,7 @@ const StoreInitialization = memo(() => {
    * IMPORTANT: Explicitly convert to boolean to avoid passing null/undefined downstream,
    * which would cause unnecessary API requests with invalid login state.
    */
-  const isLoginOnInit = Boolean(enableNextAuth ? isSignedIn : isLogin);
+  const isLoginOnInit = Boolean(isLogin);
 
   // init inbox agent via builtin agent mechanism
   useInitBuiltinAgent(INBOX_SESSION_ID, { isLogin: isLoginOnInit });

package/src/libs/better-auth/define-config.ts

@@ -23,6 +23,7 @@ import {
   getVerificationOTPEmailTemplate,
 } from '@/libs/better-auth/email-templates';
 import { initBetterAuthSSOProviders } from '@/libs/better-auth/sso';
+import { emailWhitelist } from '@/libs/better-auth/plugins/email-whitelist';
 import { createSecondaryStorage, getTrustedOrigins } from '@/libs/better-auth/utils/config';
 import { parseSSOProviders } from '@/libs/better-auth/utils/server';
 import { EmailService } from '@/server/services/email';
@@ -222,6 +223,7 @@ export function defineConfig(customOptions: CustomBetterAuthOptions) {
     },
     plugins: [
       ...customOptions.plugins,
+      emailWhitelist(),
       expo(),
       emailHarmony({ allowNormalizedSignin: false, validator: customEmailValidator }),
       admin(),

package/src/libs/better-auth/plugins/email-whitelist.test.ts

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// Get mocked module
+import { authEnv } from '@/envs/auth';
+
+import { isEmailAllowed } from './email-whitelist';
+
+// Mock authEnv
+vi.mock('@/envs/auth', () => ({
+  authEnv: {
+    AUTH_ALLOWED_EMAILS: undefined as string | undefined,
+  },
+}));
+
+describe('isEmailAllowed', () => {
+  beforeEach(() => {
+    // Reset to undefined before each test
+    (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS = undefined;
+  });
+
+  describe('when whitelist is empty', () => {
+    it('should allow all emails when AUTH_ALLOWED_EMAILS is undefined', () => {
+      expect(isEmailAllowed('anyone@example.com')).toBe(true);
+    });
+
+    it('should allow all emails when AUTH_ALLOWED_EMAILS is empty string', () => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS = '';
+      expect(isEmailAllowed('anyone@example.com')).toBe(true);
+    });
+  });
+
+  describe('domain matching', () => {
+    beforeEach(() => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS =
+        'example.com,company.org';
+    });
+
+    it('should allow email from whitelisted domain', () => {
+      expect(isEmailAllowed('user@example.com')).toBe(true);
+      expect(isEmailAllowed('admin@company.org')).toBe(true);
+    });
+
+    it('should reject email from non-whitelisted domain', () => {
+      expect(isEmailAllowed('user@other.com')).toBe(false);
+    });
+
+    it('should be case-sensitive for domain', () => {
+      expect(isEmailAllowed('user@Example.com')).toBe(false);
+      expect(isEmailAllowed('user@EXAMPLE.COM')).toBe(false);
+    });
+  });
+
+  describe('exact email matching', () => {
+    beforeEach(() => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS =
+        'admin@special.com,vip@other.com';
+    });
+
+    it('should allow exact email match', () => {
+      expect(isEmailAllowed('admin@special.com')).toBe(true);
+      expect(isEmailAllowed('vip@other.com')).toBe(true);
+    });
+
+    it('should reject different email at same domain', () => {
+      expect(isEmailAllowed('user@special.com')).toBe(false);
+    });
+
+    it('should be case-sensitive for email', () => {
+      expect(isEmailAllowed('Admin@special.com')).toBe(false);
+    });
+  });
+
+  describe('mixed domain and email matching', () => {
+    beforeEach(() => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS =
+        'example.com,admin@other.com';
+    });
+
+    it('should allow any email from whitelisted domain', () => {
+      expect(isEmailAllowed('anyone@example.com')).toBe(true);
+    });
+
+    it('should allow specific whitelisted email', () => {
+      expect(isEmailAllowed('admin@other.com')).toBe(true);
+    });
+
+    it('should reject non-whitelisted email from non-whitelisted domain', () => {
+      expect(isEmailAllowed('user@other.com')).toBe(false);
+    });
+  });
+
+  describe('whitespace handling', () => {
+    it('should trim whitespace from whitelist entries', () => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS =
+        ' example.com , admin@other.com ';
+      expect(isEmailAllowed('user@example.com')).toBe(true);
+      expect(isEmailAllowed('admin@other.com')).toBe(true);
+    });
+
+    it('should filter empty entries', () => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS =
+        'example.com,,other.com';
+      expect(isEmailAllowed('user@example.com')).toBe(true);
+      expect(isEmailAllowed('user@other.com')).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should reject malformed email without @', () => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS = 'example.com';
+      expect(isEmailAllowed('invalid-email')).toBe(false);
+    });
+
+    it('should handle email with multiple @ symbols', () => {
+      (authEnv as { AUTH_ALLOWED_EMAILS: string | undefined }).AUTH_ALLOWED_EMAILS = 'example.com';
+      // split('@')[1] returns 'middle@example.com', which won't match 'example.com'
+      expect(isEmailAllowed('user@middle@example.com')).toBe(false);
+    });
+  });
+});

package/src/libs/better-auth/plugins/email-whitelist.ts

@@ -0,0 +1,62 @@
+import { APIError } from 'better-auth/api';
+import { type BetterAuthPlugin } from 'better-auth/types';
+
+import { authEnv } from '@/envs/auth';
+
+/**
+ * Parse comma-separated email whitelist string into array.
+ */
+function parseAllowedEmails(value: string | undefined): string[] {
+  if (!value) return [];
+  return value
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Check if email is allowed based on whitelist.
+ * Supports full email (user@example.com) or domain (example.com).
+ */
+export function isEmailAllowed(email: string): boolean {
+  const allowedList = parseAllowedEmails(authEnv.AUTH_ALLOWED_EMAILS);
+  if (allowedList.length === 0) return true;
+
+  const domain = email.split('@')[1];
+
+  return allowedList.some((item) => {
+    // Full email match
+    if (item.includes('@')) return item === email;
+    // Domain match
+    return item === domain;
+  });
+}
+
+/**
+ * Better Auth plugin to restrict registration to whitelisted emails/domains.
+ * Intercepts user creation (both email signup and SSO) via databaseHooks.
+ */
+export const emailWhitelist = (): BetterAuthPlugin => ({
+  id: 'email-whitelist',
+  init() {
+    return {
+      options: {
+        databaseHooks: {
+          user: {
+            create: {
+              before: async (user) => {
+                if (!user.email) return { data: user };
+
+                if (!isEmailAllowed(user.email)) {
+                  throw new APIError('FORBIDDEN', { message: 'Email not allowed for registration' });
+                }
+
+                return { data: user };
+              },
+            },
+          },
+        },
+      },
+    };
+  },
+});

package/src/libs/next/config/define-config.ts

@@ -31,10 +31,22 @@ export function defineConfig(config: CustomNextConfig) {
     outputFileTracingIncludes: { '*': ['public/**/*', '.next/static/**/*'] },
   };
 
+  // Vercel serverless optimization: exclude musl binaries
+  // Vercel uses Amazon Linux (glibc), not Alpine Linux (musl)
+  // This saves ~45MB (29MB canvas-musl + 16MB sharp-musl)
+  const vercelConfig: NextConfig = {
+    outputFileTracingExcludes: {
+      '*': [
+        'node_modules/.pnpm/@napi-rs+canvas-*-musl*',
+        'node_modules/.pnpm/@img+sharp-libvips-*musl*',
+      ],
+    },
+  };
+
   const assetPrefix = process.env.NEXT_PUBLIC_ASSET_PREFIX;
 
   const nextConfig: NextConfig = {
-    ...(isStandaloneMode ? standaloneConfig : {}),
+    ...(isStandaloneMode ? standaloneConfig : vercelConfig),
     assetPrefix,
 
     compiler: {

package/src/libs/next/proxy/define-config.ts

@@ -7,8 +7,7 @@ import { auth } from '@/auth';
 import { LOBE_LOCALE_COOKIE } from '@/const/locale';
 import { isDesktop } from '@/const/version';
 import { appEnv } from '@/envs/app';
-import { OAUTH_AUTHORIZED, authEnv } from '@/envs/auth';
-import NextAuth from '@/libs/next-auth';
+import { authEnv } from '@/envs/auth';
 import { type Locales } from '@/locales/resources';
 import { parseBrowserLanguage } from '@/utils/locale';
 import { RouteVariants } from '@/utils/server/routeVariants';
@@ -17,12 +16,8 @@ import { createRouteMatcher } from './createRouteMatcher';
 
 // Create debug logger instances
 const logDefault = debug('middleware:default');
-const logNextAuth = debug('middleware:next-auth');
 const logBetterAuth = debug('middleware:better-auth');
 
-// OIDC session pre-sync constant
-const OIDC_SESSION_HEADER = 'x-oidc-session-sync';
-
 export function defineConfig() {
   const backendApiEndpoints = ['/api', '/trpc', '/webapi', '/oidc'];
 
@@ -169,8 +164,6 @@ export function defineConfig() {
     '/api/agent(.*)',
     '/webapi(.*)',
     '/trpc(.*)',
-    // next auth
-    '/next-auth/(.*)',
     // better auth
     '/signin',
     '/signup',
@@ -187,70 +180,6 @@ export function defineConfig() {
     '/share(.*)',
   ]);
 
-  const isProtectedRoute = createRouteMatcher([
-    '/settings(.*)',
-    '/knowledge(.*)',
-    '/onboard(.*)',
-    '/oauth(.*)',
-    // ↓ cloud ↓
-  ]);
-
-  // Initialize an Edge compatible NextAuth middleware
-  const nextAuthMiddleware = NextAuth.auth((req) => {
-    logNextAuth('NextAuth middleware processing request: %s %s', req.method, req.url);
-
-    const response = defaultMiddleware(req);
-
-    // when enable auth protection, only public route is not protected, others are all protected
-    const isProtected = appEnv.ENABLE_AUTH_PROTECTION ? !isPublicRoute(req) : isProtectedRoute(req);
-
-    logNextAuth('Route protection status: %s, %s', req.url, isProtected ? 'protected' : 'public');
-
-    // Just check if session exists
-    const session = req.auth;
-
-    // Check if next-auth throws errors
-    // refs: https://github.com/lobehub/lobe-chat/pull/1323
-    const isLoggedIn = !!session?.expires;
-
-    logNextAuth('NextAuth session status: %O', {
-      expires: session?.expires,
-      isLoggedIn,
-      userId: session?.user?.id,
-    });
-
-    // Remove & amend OAuth authorized header
-    response.headers.delete(OAUTH_AUTHORIZED);
-    if (isLoggedIn) {
-      logNextAuth('Setting auth header: %s = %s', OAUTH_AUTHORIZED, 'true');
-      response.headers.set(OAUTH_AUTHORIZED, 'true');
-
-      // If OIDC is enabled and user is logged in, add OIDC session pre-sync header
-      if (authEnv.ENABLE_OIDC && session?.user?.id) {
-        logNextAuth('OIDC session pre-sync: Setting %s = %s', OIDC_SESSION_HEADER, session.user.id);
-        response.headers.set(OIDC_SESSION_HEADER, session.user.id);
-      }
-    } else {
-      // If request a protected route, redirect to sign-in page
-      // ref: https://authjs.dev/getting-started/session-management/protecting
-      if (isProtected) {
-        logNextAuth('Request a protected route, redirecting to sign-in page');
-        const callbackUrl = `${appEnv.APP_URL}${req.nextUrl.pathname}${req.nextUrl.search}`;
-        const nextLoginUrl = new URL('/next-auth/signin', appEnv.APP_URL);
-        nextLoginUrl.searchParams.set('callbackUrl', callbackUrl);
-        const hl = req.nextUrl.searchParams.get('hl');
-        if (hl) {
-          nextLoginUrl.searchParams.set('hl', hl);
-          logNextAuth('Preserving locale to sign-in: hl=%s', hl);
-        }
-        return Response.redirect(nextLoginUrl);
-      }
-      logNextAuth('Request a free route but not login, allow visit without auth header');
-    }
-
-    return response;
-  });
-
   const betterAuthMiddleware = async (req: NextRequest) => {
     logBetterAuth('BetterAuth middleware processing request: %s %s', req.method, req.url);
 
@@ -298,12 +227,10 @@ export function defineConfig() {
 
   logDefault('Middleware configuration: %O', {
     enableAuthProtection: appEnv.ENABLE_AUTH_PROTECTION,
-    enableBetterAuth: authEnv.NEXT_PUBLIC_ENABLE_BETTER_AUTH,
-    enableNextAuth: authEnv.NEXT_PUBLIC_ENABLE_NEXT_AUTH,
     enableOIDC: authEnv.ENABLE_OIDC,
   });
 
   return {
-    middleware: authEnv.NEXT_PUBLIC_ENABLE_NEXT_AUTH ? nextAuthMiddleware : betterAuthMiddleware,
+    middleware: betterAuthMiddleware,
   };
 }

package/src/libs/oidc-provider/provider.test.ts

@@ -4,10 +4,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // Mock dependencies
-vi.mock('@/envs/auth', () => ({
-  enableBetterAuth: false,
-  enableNextAuth: false,
-}));
 
 vi.mock('@/envs/app', () => ({
   appEnv: {

package/src/libs/redis/index.ts

@@ -2,5 +2,4 @@ export * from './keys';
 export * from './manager';
 export * from './redis';
 export * from './types';
-export * from './upstash';
 export * from './utils';

package/src/libs/redis/manager.test.ts

@@ -1,23 +1,15 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { RedisManager, initializeRedis, resetRedisClient } from './manager';
-import { DisabledRedisConfig } from './types';
+import { RedisConfig } from './types';
 
-const {
-  mockIoRedisInitialize,
-  mockIoRedisDisconnect,
-  mockUpstashInitialize,
-  mockUpstashDisconnect,
-} = vi.hoisted(() => ({
+const { mockIoRedisInitialize, mockIoRedisDisconnect } = vi.hoisted(() => ({
   mockIoRedisInitialize: vi.fn().mockResolvedValue(undefined),
   mockIoRedisDisconnect: vi.fn().mockResolvedValue(undefined),
-  mockUpstashInitialize: vi.fn().mockResolvedValue(undefined),
-  mockUpstashDisconnect: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock('./redis', () => {
   const IoRedisRedisProvider = vi.fn().mockImplementation((config) => ({
-    provider: 'redis' as const,
     config,
     initialize: mockIoRedisInitialize,
     disconnect: mockIoRedisDisconnect,
@@ -26,20 +18,9 @@ vi.mock('./redis', () => {
   return { IoRedisRedisProvider };
 });
 
-vi.mock('./upstash', () => {
-  const UpstashRedisProvider = vi.fn().mockImplementation((config) => ({
-    provider: 'upstash' as const,
-    config,
-    initialize: mockUpstashInitialize,
-    disconnect: mockUpstashDisconnect,
-  }));
-
-  return { UpstashRedisProvider };
-});
-
 afterEach(async () => {
-  vi.clearAllMocks();
   await RedisManager.reset();
+  vi.clearAllMocks();
 });
 
 describe('RedisManager', () => {
@@ -47,14 +28,14 @@ describe('RedisManager', () => {
     const config = {
       enabled: false,
       prefix: 'test',
-      provider: false,
-    } satisfies DisabledRedisConfig;
+      tls: false,
+      url: '',
+    } satisfies RedisConfig;
 
     const instance = await initializeRedis(config);
 
     expect(instance).toBeNull();
     expect(mockIoRedisInitialize).not.toHaveBeenCalled();
-    expect(mockUpstashInitialize).not.toHaveBeenCalled();
   });
 
   it('initializes ioredis provider once and memoizes the instance', async () => {
@@ -63,41 +44,24 @@ describe('RedisManager', () => {
       enabled: true,
       password: 'pwd',
       prefix: 'test',
-      provider: 'redis' as const,
       tls: false,
       url: 'redis://localhost:6379',
       username: 'user',
-    };
+    } satisfies RedisConfig;
+
     const [first, second] = await Promise.all([initializeRedis(config), initializeRedis(config)]);
 
     expect(first).toBe(second);
     expect(mockIoRedisInitialize).toHaveBeenCalledTimes(1);
-    expect(mockUpstashInitialize).not.toHaveBeenCalled();
-  });
-
-  it('initializes upstash provider when configured', async () => {
-    const config = {
-      enabled: true,
-      prefix: 'test',
-      provider: 'upstash' as const,
-      token: 'token',
-      url: 'https://example.upstash.io',
-    };
-    const instance = await initializeRedis(config);
-
-    expect(instance?.provider).toBe('upstash');
-    expect(mockUpstashInitialize).toHaveBeenCalledTimes(1);
-    expect(mockIoRedisInitialize).not.toHaveBeenCalled();
   });
 
   it('disconnects existing provider on reset', async () => {
     const config = {
       enabled: true,
       prefix: 'test',
-      provider: 'redis' as const,
       tls: false,
       url: 'redis://localhost:6379',
-    };
+    } satisfies RedisConfig;
 
     await initializeRedis(config);
     await resetRedisClient();