@lobehub/lobehub 2.0.0-next.231 → 2.0.0-next.233

package/packages/model-bank/src/aiModels/openai.ts

@@ -1219,6 +1219,26 @@ export const openaiSTTModels: AISTTModelCard[] = [
 
 // Image generation models
 export const openaiImageModels: AIImageModelCard[] = [
+  {
+    description:
+      'An enhanced GPT Image 1 model with 4× faster generation, more precise editing, and improved text rendering.',
+    displayName: 'GPT Image 1.5',
+    enabled: true,
+    id: 'gpt-image-1.5',
+    parameters: gptImage1ParamsSchema,
+    pricing: {
+      approximatePricePerImage: 0.034,
+      units: [
+        { name: 'textInput', rate: 5, strategy: 'fixed', unit: 'millionTokens' },
+        { name: 'textInput_cacheRead', rate: 1.25, strategy: 'fixed', unit: 'millionTokens' },
+        { name: 'imageInput', rate: 8, strategy: 'fixed', unit: 'millionTokens' },
+        { name: 'imageInput_cacheRead', rate: 2, strategy: 'fixed', unit: 'millionTokens' },
+        { name: 'imageOutput', rate: 32, strategy: 'fixed', unit: 'millionTokens' },
+      ],
+    },
+    releasedAt: '2025-12-16',
+    type: 'image',
+  },
   // https://platform.openai.com/docs/models/gpt-image-1
   {
     description: 'ChatGPT native multimodal image generation model.',
@@ -1236,7 +1256,6 @@ export const openaiImageModels: AIImageModelCard[] = [
         { name: 'imageOutput', rate: 40, strategy: 'fixed', unit: 'millionTokens' },
       ],
     },
-    resolutions: ['1024x1024', '1024x1536', '1536x1024'],
     type: 'image',
   },
   {
@@ -1257,13 +1276,13 @@ export const openaiImageModels: AIImageModelCard[] = [
       ],
     },
     releasedAt: '2025-10-06',
-    resolutions: ['1024x1024', '1024x1536', '1536x1024'],
     type: 'image',
   },
   {
     description:
       'The latest DALL·E model, released in November 2023, supports more realistic, accurate image generation with stronger detail.',
     displayName: 'DALL·E 3',
+    enabled: true,
     id: 'dall-e-3',
     parameters: {
       prompt: { default: '' },
@@ -1296,7 +1315,6 @@ export const openaiImageModels: AIImageModelCard[] = [
         },
       ],
     },
-    resolutions: ['1024x1024', '1024x1792', '1792x1024'],
     type: 'image',
   },
   {
@@ -1329,7 +1347,6 @@ export const openaiImageModels: AIImageModelCard[] = [
         },
       ],
     },
-    resolutions: ['256x256', '512x512', '1024x1024'],
     type: 'image',
   },
 ];

package/packages/model-runtime/src/core/openaiCompatibleFactory/createImage.ts

@@ -67,7 +67,10 @@ async function generateByImageMode(
   const defaultInput = {
     n: 1,
     ...(model.includes('dall-e') ? { response_format: 'b64_json' } : {}),
-    ...(isImageEdit && model === 'gpt-image-1' ? { input_fidelity: 'high' } : {}),
+    // https://platform.openai.com/docs/api-reference/images/createEdit#images_createedit-input_fidelity
+    ...(isImageEdit && model.includes('gpt-image-') && !model.includes('mini')
+      ? { input_fidelity: 'high' }
+      : {}),
   };
 
   const options = cleanObject({

package/packages/model-runtime/src/providers/openai/__snapshots__/index.test.ts.snap

@@ -311,7 +311,7 @@ exports[`LobeOpenAI > models > should get models 1`] = `
     "contextWindowTokens": undefined,
     "description": "The latest DALL·E model, released in November 2023, supports more realistic, accurate image generation with stronger detail.",
     "displayName": "DALL·E 3",
-    "enabled": false,
+    "enabled": true,
     "functionCall": false,
     "id": "dall-e-3",
     "imageOutput": false,

package/packages/ssrf-safe-fetch/index.test.ts

@@ -49,14 +49,7 @@ describe('ssrfSafeFetch', () => {
       expect(mockFetch).toHaveBeenCalledWith(
         'https://httpbin.org/get',
         expect.objectContaining({
-          agent: expect.objectContaining({
-            requestFilterOptions: expect.objectContaining({
-              allowIPAddressList: [],
-              allowMetaIPAddress: false,
-              allowPrivateIPAddress: false,
-              denyIPAddressList: [],
-            }),
-          }),
+          agent: expect.any(Function),
         }),
       );
       expect(response).toBeInstanceOf(Response);
@@ -80,14 +73,7 @@ describe('ssrfSafeFetch', () => {
         'https://httpbin.org/post',
         expect.objectContaining({
           ...requestOptions,
-          agent: expect.objectContaining({
-            requestFilterOptions: expect.objectContaining({
-              allowIPAddressList: [],
-              allowMetaIPAddress: false,
-              allowPrivateIPAddress: false,
-              denyIPAddressList: [],
-            }),
-          }),
+          agent: expect.any(Function),
         }),
       );
     });
@@ -302,14 +288,7 @@ describe('ssrfSafeFetch', () => {
         'https://api.example.com/data',
         expect.objectContaining({
           ...requestOptions,
-          agent: expect.objectContaining({
-            requestFilterOptions: expect.objectContaining({
-              allowIPAddressList: ['127.0.0.1'],
-              allowMetaIPAddress: true,
-              allowPrivateIPAddress: true,
-              denyIPAddressList: [],
-            }),
-          }),
+          agent: expect.any(Function),
         }),
       );
 
@@ -323,19 +302,11 @@ describe('ssrfSafeFetch', () => {
 
       await ssrfSafeFetch('https://secure.example.com/api');
 
-      // Verify that the agent is properly configured for HTTPS
+      // Verify that the agent function is passed
       expect(mockFetch).toHaveBeenCalledWith(
         'https://secure.example.com/api',
         expect.objectContaining({
-          agent: expect.objectContaining({
-            protocol: 'https:',
-            requestFilterOptions: expect.objectContaining({
-              allowIPAddressList: [],
-              allowMetaIPAddress: false,
-              allowPrivateIPAddress: false,
-              denyIPAddressList: [],
-            }),
-          }),
+          agent: expect.any(Function),
         }),
       );
     });

package/packages/ssrf-safe-fetch/index.ts

@@ -1,5 +1,9 @@
 import fetch from 'node-fetch';
-import { RequestFilteringAgentOptions, useAgent as ssrfAgent } from 'request-filtering-agent';
+import {
+  RequestFilteringAgentOptions,
+  RequestFilteringHttpAgent,
+  RequestFilteringHttpsAgent,
+} from 'request-filtering-agent';
 
 /**
  * Options for per-call SSRF configuration overrides
@@ -42,10 +46,16 @@ export const ssrfSafeFetch = async (
       denyIPAddressList: [],
     };
 
+    // Create agents for both protocols
+    const httpAgent = new RequestFilteringHttpAgent(agentOptions);
+    const httpsAgent = new RequestFilteringHttpsAgent(agentOptions);
+
     // Use node-fetch with SSRF protection agent
+    // Pass a function to dynamically select agent based on URL protocol
+    // This handles redirects from HTTP to HTTPS correctly
     const response = await fetch(url, {
       ...options,
-      agent: ssrfAgent(url, agentOptions),
+      agent: (parsedURL: URL) => (parsedURL.protocol === 'https:' ? httpsAgent : httpAgent),
     } as any);
 
     // Convert node-fetch Response to standard Response

package/src/app/[variants]/(main)/image/_layout/ConfigPanel/components/MultiImagesUpload/index.tsx

@@ -93,8 +93,8 @@ const styles = createStaticStyles(({ css }) => {
 
       overflow: hidden;
 
-      width: ${thumbnailSize};
-      height: ${thumbnailSize};
+      width: ${thumbnailSize}px;
+      height: ${thumbnailSize}px;
       border-radius: ${cssVar.borderRadius};
 
       background: ${cssVar.colorBgContainer};
@@ -112,7 +112,7 @@ const styles = createStaticStyles(({ css }) => {
       gap: 8px;
 
       width: 100%;
-      height: ${thumbnailSize};
+      height: ${thumbnailSize}px;
       padding: 0;
       border-radius: ${cssVar.borderRadiusLG};
 

package/src/app/[variants]/(main)/image/features/GenerationFeed/index.tsx

@@ -77,15 +77,8 @@ const GenerationFeed = memo(() => {
   }
 
   return (
-    <>
-      <Flexbox
-        gap={16}
-        ref={parent}
-        style={{
-          minHeight: 'calc(100vh - 180px)',
-        }}
-        width="100%"
-      >
+    <Flexbox flex={1}>
+      <Flexbox gap={16} ref={parent} width="100%">
         {currentGenerationBatches.map((batch, index) => (
           <Fragment key={batch.id}>
             {Boolean(index !== 0) && <Divider dashed style={{ margin: 0 }} />}
@@ -95,7 +88,7 @@ const GenerationFeed = memo(() => {
       </Flexbox>
       {/* Invisible element for scroll target */}
       <div ref={containerRef} style={{ height: 1 }} />
-    </>
+    </Flexbox>
   );
 });
 

package/src/app/[variants]/(main)/image/index.tsx

@@ -15,7 +15,7 @@ const DesktopImagePage = memo(() => {
     <>
       <NavHeader right={<WideScreenButton />} />
       <Flexbox height={'100%'} style={{ overflowY: 'auto', position: 'relative' }} width={'100%'}>
-        <WideScreenContainer>
+        <WideScreenContainer height={'100%'} wrapperStyle={{ height: '100%' }}>
           <Suspense fallback={<SkeletonList />}>
             <ImageWorkspace />
           </Suspense>

package/src/components/Loading/BrandTextLoading/index.module.css

@@ -0,0 +1,81 @@
+.container {
+  --brand-text-color: var(--colorText, #1f1f1f);
+  --brand-muted-color: var(--colorTextSecondary, #8c8c8c);
+  --brand-border-color: var(--colorBorder, #d9d9d9);
+  --brand-tag-bg: var(--colorFillTertiary, rgba(0, 0, 0, 0.04));
+
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+
+  width: 100%;
+  height: 100vh;
+  height: 100dvh;
+  gap: 12px;
+}
+
+[data-theme='dark'] .container {
+  --brand-text-color: var(--colorText, #f0f0f0);
+  --brand-muted-color: var(--colorTextSecondary, #a6a6a6);
+  --brand-border-color: var(--colorBorder, #424242);
+  --brand-tag-bg: var(--colorFillTertiary, rgba(255, 255, 255, 0.08));
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+
+  opacity: 0.6;
+  color: var(--brand-text-color);
+}
+
+.brand :global(.lobe-brand-loading) {
+  display: block;
+  color: inherit;
+}
+
+.debug {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 4px;
+
+  padding: 16px;
+}
+
+.debugRow {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+
+  font-size: 12px;
+  color: var(--brand-muted-color);
+}
+
+.debugRow code {
+  font-family:
+    ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New',
+    monospace;
+}
+
+.debugTag {
+  display: inline-flex;
+  align-items: center;
+
+  padding: 2px 8px;
+  border: 1px solid var(--brand-border-color);
+  border-radius: 6px;
+
+  background: var(--brand-tag-bg);
+}
+
+.debugTag code {
+  color: var(--brand-text-color);
+}
+
+.debugHint {
+  font-size: 12px;
+  color: var(--brand-muted-color);
+}

package/src/components/Loading/BrandTextLoading/index.tsx

@@ -1,34 +1,41 @@
-import { Center, Tag, Text } from '@lobehub/ui';
 import { BrandLoading, LobeHubText } from '@lobehub/ui/brand';
 
 import { isCustomBranding } from '@/const/version';
 
 import CircleLoading from '../CircleLoading';
+import styles from './index.module.css';
 
 interface BrandTextLoadingProps {
   debugId: string;
 }
 
 const BrandTextLoading = ({ debugId }: BrandTextLoadingProps) => {
-  if (isCustomBranding) return <CircleLoading />;
+  if (isCustomBranding)
+    return (
+      <div className={styles.container}>
+        <CircleLoading />
+      </div>
+    );
+
+  const showDebug = process.env.NODE_ENV === 'development' && debugId;
 
   return (
-    <Center height={'100%'} width={'100%'}>
-      <BrandLoading size={40} style={{ opacity: 0.6 }} text={LobeHubText} />
-      {process.env.NODE_ENV === 'development' && debugId && (
-        <Center gap={4} padding={16}>
-          <Text code style={{ alignItems: 'center', display: 'flex' }}>
-            Debug ID:{' '}
-            <Tag size={'large'}>
-              <Text code>{debugId}</Text>
-            </Tag>
-          </Text>
-          <Text fontSize={12} type={'secondary'}>
-            only visible in development
-          </Text>
-        </Center>
+    <div className={styles.container}>
+      <div aria-label="Loading" className={styles.brand} role="status">
+        <BrandLoading size={40} text={LobeHubText} />
+      </div>
+      {showDebug && (
+        <div className={styles.debug}>
+          <div className={styles.debugRow}>
+            <code>Debug ID:</code>
+            <span className={styles.debugTag}>
+              <code>{debugId}</code>
+            </span>
+          </div>
+          <div className={styles.debugHint}>only visible in development</div>
+        </div>
       )}
-    </Center>
+    </div>
   );
 };
 

package/src/envs/auth.ts

@@ -158,6 +158,15 @@ declare global {
        * Can be generated using `node scripts/generate-oidc-jwk.mjs`.
        */
       JWKS_KEY?: string;
+
+      /**
+       * Internal JWT expiration time for lambda → async calls.
+       * Format: number followed by unit (s=seconds, m=minutes, h=hours)
+       * Examples: '10s', '1m', '1h'
+       * Should be as short as possible for security, but long enough to account for network latency and server processing time.
+       * @default '30s'
+       */
+      INTERNAL_JWT_EXPIRATION?: string;
     }
   }
 }
@@ -285,6 +294,9 @@ export const getAuthConfig = () => {
       // Generic JWKS key for signing/verifying JWTs
       JWKS_KEY: z.string().optional(),
       ENABLE_OIDC: z.boolean(),
+
+      // Internal JWT expiration time (e.g., '10s', '1m', '1h')
+      INTERNAL_JWT_EXPIRATION: z.string().default('30s'),
     },
 
     runtimeEnv: {
@@ -415,6 +427,9 @@ export const getAuthConfig = () => {
       // Generic JWKS key (fallback to OIDC_JWKS_KEY for backward compatibility)
       JWKS_KEY: process.env.JWKS_KEY || process.env.OIDC_JWKS_KEY,
       ENABLE_OIDC: !!(process.env.JWKS_KEY || process.env.OIDC_JWKS_KEY),
+
+      // Internal JWT expiration time
+      INTERNAL_JWT_EXPIRATION: process.env.INTERNAL_JWT_EXPIRATION,
     },
   });
 };

package/src/hooks/useFetchAiImageConfig.ts

@@ -1,12 +1,26 @@
-import { useEffect } from 'react';
+import { useEffect, useMemo } from 'react';
 
 import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
 import { useGlobalStore } from '@/store/global';
 import { systemStatusSelectors } from '@/store/global/selectors';
 import { useImageStore } from '@/store/image';
+import {
+  DEFAULT_AI_IMAGE_MODEL,
+  DEFAULT_AI_IMAGE_PROVIDER,
+} from '@/store/image/slices/generationConfig/initialState';
 import { useUserStore } from '@/store/user';
 import { authSelectors } from '@/store/user/selectors';
 
+const checkModelEnabled = (
+  enabledImageModelList: ReturnType<typeof aiProviderSelectors.enabledImageModelList>,
+  provider: string,
+  model: string,
+) => {
+  return enabledImageModelList.some(
+    (p) => p.id === provider && p.children.some((m) => m.id === model),
+  );
+};
+
 export const useFetchAiImageConfig = () => {
   const isStatusInit = useGlobalStore(systemStatusSelectors.isStatusInit);
   const isInitAiProviderRuntimeState = useAiInfraStore(
@@ -29,16 +43,46 @@ export const useFetchAiImageConfig = () => {
   const isInitializedImageConfig = useImageStore((s) => s.isInit);
   const initializeImageConfig = useImageStore((s) => s.initializeImageConfig);
 
+  const enabledImageModelList = useAiInfraStore(aiProviderSelectors.enabledImageModelList);
+
+  // Determine which model/provider to use for initialization
+  const initParams = useMemo(() => {
+    // 1. Try lastSelected if enabled
+    if (
+      lastSelectedImageModel &&
+      lastSelectedImageProvider &&
+      checkModelEnabled(enabledImageModelList, lastSelectedImageProvider, lastSelectedImageModel)
+    ) {
+      return { model: lastSelectedImageModel, provider: lastSelectedImageProvider };
+    }
+
+    // 2. Try default model from any enabled provider (prefer default provider first)
+    if (
+      checkModelEnabled(enabledImageModelList, DEFAULT_AI_IMAGE_PROVIDER, DEFAULT_AI_IMAGE_MODEL)
+    ) {
+      return { model: undefined, provider: undefined }; // Use initialState defaults
+    }
+    const providerWithDefaultModel = enabledImageModelList.find((p) =>
+      p.children.some((m) => m.id === DEFAULT_AI_IMAGE_MODEL),
+    );
+    if (providerWithDefaultModel) {
+      return { model: DEFAULT_AI_IMAGE_MODEL, provider: providerWithDefaultModel.id };
+    }
+
+    // 3. Fallback to first enabled model
+    const firstProvider = enabledImageModelList[0];
+    const firstModel = firstProvider?.children[0];
+    if (firstProvider && firstModel) {
+      return { model: firstModel.id, provider: firstProvider.id };
+    }
+
+    // No enabled models
+    return { model: undefined, provider: undefined };
+  }, [lastSelectedImageModel, lastSelectedImageProvider, enabledImageModelList]);
+
   useEffect(() => {
     if (!isInitializedImageConfig && isReadyForInit) {
-      initializeImageConfig(isLogin, lastSelectedImageModel, lastSelectedImageProvider);
+      initializeImageConfig(isLogin, initParams.model, initParams.provider);
     }
-  }, [
-    isReadyForInit,
-    isInitializedImageConfig,
-    isLogin,
-    lastSelectedImageModel,
-    lastSelectedImageProvider,
-    initializeImageConfig,
-  ]);
+  }, [isReadyForInit, isInitializedImageConfig, isLogin, initParams, initializeImageConfig]);
 };

package/src/libs/redis/manager.ts

@@ -94,3 +94,66 @@ export const createRedisWithPrefix = async (
   await provider.initialize();
   return provider;
 };
+
+/**
+ * Manages singleton Redis clients per prefix
+ */
+class PrefixedRedisManager {
+  private static instances = new Map<string, BaseRedisProvider>();
+  private static initPromises = new Map<string, Promise<BaseRedisProvider | null>>();
+
+  static async initialize(config: RedisConfig, prefix: string): Promise<BaseRedisProvider | null> {
+    const existing = this.instances.get(prefix);
+    if (existing) return existing;
+
+    const pendingPromise = this.initPromises.get(prefix);
+    if (pendingPromise) return pendingPromise;
+
+    const initPromise = (async () => {
+      const provider = createProvider(config, prefix);
+      if (!provider) return null;
+
+      await provider.initialize();
+      this.instances.set(prefix, provider);
+      return provider;
+    })().catch((error) => {
+      this.initPromises.delete(prefix);
+      throw error;
+    });
+
+    this.initPromises.set(prefix, initPromise);
+    return initPromise;
+  }
+
+  static async reset(prefix?: string) {
+    if (prefix) {
+      const instance = this.instances.get(prefix);
+      if (instance) {
+        await instance.disconnect();
+        this.instances.delete(prefix);
+        this.initPromises.delete(prefix);
+      }
+    } else {
+      for (const instance of this.instances.values()) {
+        await instance.disconnect();
+      }
+      this.instances.clear();
+      this.initPromises.clear();
+    }
+  }
+}
+
+/**
+ * Initialize a singleton Redis client with custom prefix
+ *
+ * Unlike createRedisWithPrefix, this reuses the same client for each prefix,
+ * avoiding connection leaks when called frequently.
+ *
+ * @param config - Redis config
+ * @param prefix - Custom prefix for all keys (e.g., 'aiGeneration')
+ * @returns Redis client or null if Redis is disabled
+ */
+export const initializeRedisWithPrefix = (config: RedisConfig, prefix: string) =>
+  PrefixedRedisManager.initialize(config, prefix);
+
+export const resetPrefixedRedisClient = (prefix?: string) => PrefixedRedisManager.reset(prefix);

package/src/libs/trpc/utils/internalJwt.ts

@@ -66,7 +66,7 @@ const getVerificationKey = async () => {
 
 /**
  * Sign JWT for internal lambda → async calls
- * Uses JWKS private key with short expiration (3s)
+ * Uses JWKS private key with configurable expiration (default: 30s)
  * The JWT only proves the request is from lambda, payload is sent via LOBE_CHAT_AUTH_HEADER
  */
 export const signInternalJWT = async (): Promise<string> => {
@@ -75,7 +75,7 @@ export const signInternalJWT = async (): Promise<string> => {
   return new SignJWT({ purpose: INTERNAL_JWT_PURPOSE })
     .setProtectedHeader({ alg: 'RS256', kid })
     .setIssuedAt()
-    .setExpirationTime('3s')
+    .setExpirationTime(authEnv.INTERNAL_JWT_EXPIRATION)
     .sign(key);
 };
 

package/src/server/services/agent/index.test.ts

@@ -5,7 +5,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { AgentModel } from '@/database/models/agent';
 import { SessionModel } from '@/database/models/session';
 import { UserModel } from '@/database/models/user';
-import { RedisKeys, createRedisWithPrefix } from '@/libs/redis';
+import { RedisKeys, initializeRedisWithPrefix, isRedisEnabled } from '@/libs/redis';
 import { parseAgentConfig } from '@/server/globalConfig/parseDefaultAgent';
 
 import { AgentService } from './index';
@@ -43,7 +43,8 @@ vi.mock('@/libs/redis', async (importOriginal) => {
   const original = await importOriginal<typeof import('@/libs/redis')>();
   return {
     ...original,
-    createRedisWithPrefix: vi.fn(),
+    initializeRedisWithPrefix: vi.fn(),
+    isRedisEnabled: vi.fn(),
   };
 });
 
@@ -290,7 +291,8 @@ describe('AgentService', () => {
       const mockRedisClient = { get: mockRedisGet };
 
       beforeEach(() => {
-        vi.mocked(createRedisWithPrefix).mockReset();
+        vi.mocked(initializeRedisWithPrefix).mockReset();
+        vi.mocked(isRedisEnabled).mockReset();
         mockRedisGet.mockReset();
       });
 
@@ -310,7 +312,8 @@ describe('AgentService', () => {
 
         (AgentModel as any).mockImplementation(() => mockAgentModel);
         (parseAgentConfig as any).mockReturnValue({});
-        vi.mocked(createRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
+        vi.mocked(isRedisEnabled).mockReturnValue(true);
+        vi.mocked(initializeRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
         mockRedisGet.mockResolvedValue(JSON.stringify(welcomeData));
 
         const newService = new AgentService(mockDb, mockUserId);
@@ -334,7 +337,7 @@ describe('AgentService', () => {
 
         (AgentModel as any).mockImplementation(() => mockAgentModel);
         (parseAgentConfig as any).mockReturnValue({});
-        vi.mocked(createRedisWithPrefix).mockResolvedValue(null);
+        vi.mocked(isRedisEnabled).mockReturnValue(false);
 
         const newService = new AgentService(mockDb, mockUserId);
         const result = await newService.getAgentConfigById('agent-1');
@@ -343,6 +346,7 @@ describe('AgentService', () => {
         expect(result?.openingMessage).toBe('Default message');
         // openingQuestions comes from DEFAULT_AGENT_CONFIG (empty array)
         expect(result?.openingQuestions).toEqual([]);
+        expect(initializeRedisWithPrefix).not.toHaveBeenCalled();
       });
 
       it('should return normal config when Redis key does not exist', async () => {
@@ -357,7 +361,8 @@ describe('AgentService', () => {
 
         (AgentModel as any).mockImplementation(() => mockAgentModel);
         (parseAgentConfig as any).mockReturnValue({});
-        vi.mocked(createRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
+        vi.mocked(isRedisEnabled).mockReturnValue(true);
+        vi.mocked(initializeRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
         mockRedisGet.mockResolvedValue(null);
 
         const newService = new AgentService(mockDb, mockUserId);
@@ -381,7 +386,8 @@ describe('AgentService', () => {
 
         (AgentModel as any).mockImplementation(() => mockAgentModel);
         (parseAgentConfig as any).mockReturnValue({});
-        vi.mocked(createRedisWithPrefix).mockRejectedValue(new Error('Redis connection failed'));
+        vi.mocked(isRedisEnabled).mockReturnValue(true);
+        vi.mocked(initializeRedisWithPrefix).mockRejectedValue(new Error('Redis connection failed'));
 
         const newService = new AgentService(mockDb, mockUserId);
         const result = await newService.getAgentConfigById('agent-1');
@@ -403,7 +409,8 @@ describe('AgentService', () => {
 
         (AgentModel as any).mockImplementation(() => mockAgentModel);
         (parseAgentConfig as any).mockReturnValue({});
-        vi.mocked(createRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
+        vi.mocked(isRedisEnabled).mockReturnValue(true);
+        vi.mocked(initializeRedisWithPrefix).mockResolvedValue(mockRedisClient as any);
         mockRedisGet.mockResolvedValue('invalid json {');
 
         const newService = new AgentService(mockDb, mockUserId);