@lobehub/chat 1.106.0 → 1.106.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 1.106.1](https://github.com/lobehub/lobe-chat/compare/v1.106.0...v1.106.1)
+
+<sup>Released on **2025-07-29**</sup>
+
+#### 💄 Styles
+
+- **misc**: Support Minimax T2I models.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Styles
+
+- **misc**: Support Minimax T2I models, closes [#8583](https://github.com/lobehub/lobe-chat/issues/8583) ([f8a01aa](https://github.com/lobehub/lobe-chat/commit/f8a01aa))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 1.106.0](https://github.com/lobehub/lobe-chat/compare/v1.105.6...v1.106.0)
 
 <sup>Released on **2025-07-29**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Support Minimax T2I models."
+      ]
+    },
+    "date": "2025-07-29",
+    "version": "1.106.1"
+  },
   {
     "children": {
       "features": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.106.0",
+  "version": "1.106.1",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/app/[variants]/(main)/image/@topic/features/Topics/TopicList.tsx

@@ -5,15 +5,18 @@ import { useSize } from 'ahooks';
 import { memo, useRef } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
-import { useFetchGenerationTopics } from '@/hooks/useFetchGenerationTopics';
 import { useImageStore } from '@/store/image';
 import { generationTopicSelectors } from '@/store/image/selectors';
+import { useUserStore } from '@/store/user';
+import { authSelectors } from '@/store/user/slices/auth/selectors';
 
 import NewTopicButton from './NewTopicButton';
 import TopicItem from './TopicItem';
 
 const TopicsList = memo(() => {
-  useFetchGenerationTopics();
+  const isLogin = useUserStore(authSelectors.isLogin);
+  const useFetchGenerationTopics = useImageStore((s) => s.useFetchGenerationTopics);
+  useFetchGenerationTopics(!!isLogin);
   const ref = useRef(null);
   const { width = 80 } = useSize(ref) || {};
   const [parent] = useAutoAnimate();

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

@@ -7,9 +7,12 @@ import type { KeyboardEvent } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
+import { loginRequired } from '@/components/Error/loginRequiredNotification';
 import { useImageStore } from '@/store/image';
 import { createImageSelectors } from '@/store/image/selectors';
 import { useGenerationConfigParam } from '@/store/image/slices/generationConfig/hooks';
+import { useUserStore } from '@/store/user';
+import { authSelectors } from '@/store/user/slices/auth/selectors';
 
 import PromptTitle from './Title';
 
@@ -46,8 +49,14 @@ const PromptInput = ({ showTitle = false }: PromptInputProps) => {
   const { value, setValue } = useGenerationConfigParam('prompt');
   const isCreating = useImageStore(createImageSelectors.isCreating);
   const createImage = useImageStore((s) => s.createImage);
+  const isLogin = useUserStore(authSelectors.isLogin);
 
   const handleGenerate = async () => {
+    if (!isLogin) {
+      loginRequired.redirect({ timeout: 2000 });
+      return;
+    }
+
     await createImage();
   };
 

package/src/config/aiModels/minimax.ts

@@ -1,4 +1,4 @@
-import { AIChatModelCard } from '@/types/aiModel';
+import { AIChatModelCard, AIImageModelCard } from '@/types/aiModel';
 
 const minimaxChatModels: AIChatModelCard[] = [
   {
@@ -51,6 +51,47 @@ const minimaxChatModels: AIChatModelCard[] = [
   },
 ];
 
-export const allModels = [...minimaxChatModels];
+const minimaxImageModels: AIImageModelCard[] = [
+  {
+    description:
+      '全新图像生成模型，画面表现细腻，支持文生图、图生图',
+    displayName: 'Image 01',
+    enabled: true,
+    id: 'image-01',
+    parameters: {
+      aspectRatio: {
+        default: '1:1',
+        enum: ['1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9'],
+      },
+      prompt: {
+        default: '',
+      },
+      seed: { default: null },
+    },
+    releasedAt: '2025-02-28',
+    type: 'image',
+  },
+  {
+    description:
+      '图像生成模型，画面表现细腻，支持文生图并进行画风设置',
+    displayName: 'Image 01 Live',
+    enabled: true,
+    id: 'image-01-live',
+    parameters: {
+      aspectRatio: {
+        default: '1:1',
+        enum: ['1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9'],
+      },
+      prompt: {
+        default: '',
+      },
+      seed: { default: null },
+    },
+    releasedAt: '2025-02-28',
+    type: 'image',
+  },
+];
+
+export const allModels = [...minimaxChatModels, ...minimaxImageModels];
 
 export default allModels;

package/src/libs/model-runtime/minimax/createImage.test.ts

@@ -0,0 +1,553 @@
+// @vitest-environment edge-runtime
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CreateImagePayload } from '../types/image';
+import { CreateImageOptions } from '../utils/openaiCompatibleFactory';
+import { createMiniMaxImage } from './createImage';
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+const mockOptions: CreateImageOptions = {
+  apiKey: 'test-api-key',
+  baseURL: 'https://api.minimaxi.com/v1',
+  provider: 'minimax',
+};
+
+beforeEach(() => {
+  // Reset all mocks before each test
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('createMiniMaxImage', () => {
+  describe('Success scenarios', () => {
+    it('should successfully generate image with basic prompt', async () => {
+      const mockImageUrl = 'https://minimax-cdn.com/images/generated/test-image.jpg';
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [mockImageUrl],
+          },
+          id: 'img-123456',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'A beautiful sunset over the mountains',
+        },
+      };
+
+      const result = await createMiniMaxImage(payload, mockOptions);
+
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.minimaxi.com/v1/image_generation',
+        {
+          method: 'POST',
+          headers: {
+            'Authorization': 'Bearer test-api-key',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            aspect_ratio: undefined,
+            model: 'image-01',
+            n: 1,
+            prompt: 'A beautiful sunset over the mountains',
+          }),
+        },
+      );
+
+      expect(result).toEqual({
+        imageUrl: mockImageUrl,
+      });
+    });
+
+    it('should handle custom aspect ratio', async () => {
+      const mockImageUrl = 'https://minimax-cdn.com/images/generated/custom-ratio.jpg';
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [mockImageUrl],
+          },
+          id: 'img-custom-ratio',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Abstract digital art',
+          aspectRatio: '16:9',
+        },
+      };
+
+      const result = await createMiniMaxImage(payload, mockOptions);
+
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.minimaxi.com/v1/image_generation',
+        expect.objectContaining({
+          body: JSON.stringify({
+            aspect_ratio: '16:9',
+            model: 'image-01',
+            n: 1,
+            prompt: 'Abstract digital art',
+          }),
+        }),
+      );
+
+      expect(result).toEqual({
+        imageUrl: mockImageUrl,
+      });
+    });
+
+    it('should handle seed value correctly', async () => {
+      const mockImageUrl = 'https://minimax-cdn.com/images/generated/seeded-image.jpg';
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [mockImageUrl],
+          },
+          id: 'img-seeded',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Reproducible image with seed',
+          seed: 42,
+        },
+      };
+
+      const result = await createMiniMaxImage(payload, mockOptions);
+
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.minimaxi.com/v1/image_generation',
+        expect.objectContaining({
+          body: JSON.stringify({
+            aspect_ratio: undefined,
+            model: 'image-01',
+            n: 1,
+            prompt: 'Reproducible image with seed',
+            seed: 42,
+          }),
+        }),
+      );
+
+      expect(result).toEqual({
+        imageUrl: mockImageUrl,
+      });
+    });
+
+    it('should handle seed value of 0 correctly', async () => {
+      const mockImageUrl = 'https://minimax-cdn.com/images/generated/zero-seed.jpg';
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [mockImageUrl],
+          },
+          id: 'img-zero-seed',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Image with seed 0',
+          seed: 0,
+        },
+      };
+
+      await createMiniMaxImage(payload, mockOptions);
+
+      // Verify that seed: 0 is included in the request
+      expect(fetch).toHaveBeenCalledWith(
+        'https://api.minimaxi.com/v1/image_generation',
+        expect.objectContaining({
+          body: JSON.stringify({
+            aspect_ratio: undefined,
+            model: 'image-01',
+            n: 1,
+            prompt: 'Image with seed 0',
+            seed: 0,
+          }),
+        }),
+      );
+    });
+
+    it('should handle multiple generated images and return the first one', async () => {
+      const mockImageUrls = [
+        'https://minimax-cdn.com/images/generated/image-1.jpg',
+        'https://minimax-cdn.com/images/generated/image-2.jpg',
+      ];
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: mockImageUrls,
+          },
+          id: 'img-multiple',
+          metadata: {
+            failed_count: '0',
+            success_count: '2',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Multiple images test',
+        },
+      };
+
+      const result = await createMiniMaxImage(payload, mockOptions);
+
+      expect(result).toEqual({
+        imageUrl: mockImageUrls[0], // Should return the first image
+      });
+    });
+
+    it('should handle partial failures gracefully', async () => {
+      const mockImageUrl = 'https://minimax-cdn.com/images/generated/partial-success.jpg';
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [mockImageUrl],
+          },
+          id: 'img-partial',
+          metadata: {
+            failed_count: '2',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Test partial failure',
+        },
+      };
+
+      const result = await createMiniMaxImage(payload, mockOptions);
+
+      expect(result).toEqual({
+        imageUrl: mockImageUrl,
+      });
+    });
+  });
+
+  describe('Error scenarios', () => {
+    it('should handle HTTP error responses', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({
+          base_resp: {
+            status_code: 1001,
+            status_msg: 'Invalid prompt format',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Invalid prompt',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle non-JSON error responses', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: async () => {
+          throw new Error('Failed to parse JSON');
+        },
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Test prompt',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle API error status codes', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 1002,
+            status_msg: 'Content policy violation',
+          },
+          data: {
+            image_urls: [],
+          },
+          id: 'img-error',
+          metadata: {
+            failed_count: '1',
+            success_count: '0',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Inappropriate content',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle empty image URLs array', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [],
+          },
+          id: 'img-empty',
+          metadata: {
+            failed_count: '1',
+            success_count: '0',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Empty result test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle missing data field', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          id: 'img-no-data',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Missing data test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle null/empty image URL', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          base_resp: {
+            status_code: 0,
+            status_msg: 'success',
+          },
+          data: {
+            image_urls: [''], // Empty string URL
+          },
+          id: 'img-empty-url',
+          metadata: {
+            failed_count: '0',
+            success_count: '1',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Empty URL test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle network errors', async () => {
+      global.fetch = vi.fn().mockRejectedValueOnce(new Error('Network connection failed'));
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Network error test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle unauthorized access', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        statusText: 'Unauthorized',
+        json: async () => ({
+          base_resp: {
+            status_code: 1003,
+            status_msg: 'Invalid API key',
+          },
+        }),
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'Unauthorized test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+
+    it('should handle malformed JSON response', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        json: async () => {
+          throw new Error('Unexpected token in JSON');
+        },
+      });
+
+      const payload: CreateImagePayload = {
+        model: 'image-01',
+        params: {
+          prompt: 'JSON error test',
+        },
+      };
+
+      await expect(createMiniMaxImage(payload, mockOptions)).rejects.toEqual(
+        expect.objectContaining({
+          errorType: 'ProviderBizError',
+          provider: 'minimax',
+        }),
+      );
+    });
+  });
+});

package/src/libs/model-runtime/minimax/createImage.ts

@@ -0,0 +1,105 @@
+import createDebug from 'debug';
+
+import { CreateImagePayload, CreateImageResponse } from '../types/image';
+import { AgentRuntimeError } from '../utils/createError';
+import { CreateImageOptions } from '../utils/openaiCompatibleFactory';
+
+const log = createDebug('lobe-image:minimax');
+
+interface MiniMaxImageResponse {
+  base_resp: {
+    status_code: number;
+    status_msg: string;
+  };
+  data: {
+    image_urls: string[];
+  };
+  id: string;
+  metadata: {
+    failed_count: string;
+    success_count: string;
+  };
+}
+
+/**
+ * Create image using MiniMax API
+ */
+export async function createMiniMaxImage(
+  payload: CreateImagePayload,
+  options: CreateImageOptions,
+): Promise<CreateImageResponse> {
+  const { apiKey, baseURL, provider } = options;
+  const { model, params } = payload;
+
+  try {
+    const endpoint = `${baseURL}/image_generation`;
+
+    const response = await fetch(endpoint, {
+      body: JSON.stringify({
+        aspect_ratio: params.aspectRatio,
+        model,
+        n: 1,
+        prompt: params.prompt,
+        //prompt_optimizer: true, // 开启 prompt 自动优化
+        ...(typeof params.seed === 'number' ? { seed: params.seed } : {}),
+      }),
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+    });
+
+    if (!response.ok) {
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        // Failed to parse JSON error response
+      }
+
+      throw new Error(
+        `MiniMax API error (${response.status}): ${errorData?.base_resp || response.statusText}`
+      );
+    }
+
+    const data: MiniMaxImageResponse = await response.json();
+
+    log('Image generation response: %O', data);
+
+    // Check API response status
+    if (data.base_resp.status_code !== 0) {
+      throw new Error(`MiniMax API error: ${data.base_resp.status_msg}`);
+    }
+
+    // Check if we have valid image data
+    if (!data.data?.image_urls || data.data.image_urls.length === 0) {
+      throw new Error('No images generated in response');
+    }
+
+    // Log generation statistics
+    const successCount = parseInt(data.metadata.success_count);
+    const failedCount = parseInt(data.metadata.failed_count);
+    log('Image generation completed: %d successful, %d failed', successCount, failedCount);
+
+    // Return the first generated image URL
+    const imageUrl = data.data.image_urls[0];
+
+    if (!imageUrl) {
+      throw new Error('No valid image URL in response');
+    }
+
+    log('Image generated successfully: %s', imageUrl);
+
+    return { imageUrl };
+
+  } catch (error) {
+    log('Error in createMiniMaxImage: %O', error);
+
+    throw AgentRuntimeError.createImage({
+      error: error as any,
+      errorType: 'ProviderBizError',
+      provider,
+    });
+  }
+}

package/src/libs/model-runtime/minimax/index.ts

@@ -2,6 +2,7 @@ import minimaxChatModels from '@/config/aiModels/minimax';
 
 import { ModelProvider } from '../types';
 import { createOpenAICompatibleRuntime } from '../utils/openaiCompatibleFactory';
+import { createMiniMaxImage } from './createImage';
 
 export const getMinimaxMaxOutputs = (modelId: string): number | undefined => {
   const model = minimaxChatModels.find((model) => model.id === modelId);
@@ -34,6 +35,7 @@ export const LobeMinimaxAI = createOpenAICompatibleRuntime({
       } as any;
     },
   },
+  createImage: createMiniMaxImage,
   debug: {
     chatCompletion: () => process.env.DEBUG_MINIMAX_CHAT_COMPLETION === '1',
   },

package/src/store/image/slices/generationTopic/action.test.ts

@@ -405,7 +405,7 @@ describe('GenerationTopicAction', () => {
         const { result } = renderHook(() => {
           const store = useImageStore();
           // Actually call the SWR hook to trigger the service call
-          const swrResult = store.useFetchGenerationTopics(true, true);
+          const swrResult = store.useFetchGenerationTopics(true);
 
           // Simulate the SWR onSuccess callback behavior
           React.useEffect(() => {
@@ -426,7 +426,7 @@ describe('GenerationTopicAction', () => {
     });
 
     it('should not fetch when disabled', async () => {
-      const { result } = renderHook(() => useImageStore().useFetchGenerationTopics(false, true));
+      const { result } = renderHook(() => useImageStore().useFetchGenerationTopics(false));
 
       expect(result.current.data).toBeUndefined();
       expect(generationTopicService.getAllGenerationTopics).not.toHaveBeenCalled();
@@ -455,7 +455,7 @@ describe('GenerationTopicAction', () => {
         await result.current.refreshGenerationTopics();
       });
 
-      expect(mutate).toHaveBeenCalledWith(['fetchGenerationTopics', true]);
+      expect(mutate).toHaveBeenCalledWith(['fetchGenerationTopics']);
     });
   });
 

package/src/store/image/slices/generationTopic/action.ts

@@ -25,10 +25,7 @@ const n = setNamespace('generationTopic');
 export interface GenerationTopicAction {
   createGenerationTopic: (prompts: string[]) => Promise<string>;
   removeGenerationTopic: (id: string) => Promise<void>;
-  useFetchGenerationTopics: (
-    enabled: boolean,
-    isLogin: boolean | undefined,
-  ) => SWRResponse<ImageGenerationTopic[]>;
+  useFetchGenerationTopics: (enabled: boolean) => SWRResponse<ImageGenerationTopic[]>;
   summaryGenerationTopicTitle: (topicId: string, prompts: string[]) => Promise<string>;
   refreshGenerationTopics: () => Promise<void>;
   switchGenerationTopic: (topicId: string) => void;
@@ -216,9 +213,9 @@ export const createGenerationTopicSlice: StateCreator<
     );
   },
 
-  useFetchGenerationTopics: (enabled, isLogin) =>
+  useFetchGenerationTopics: (enabled) =>
     useClientDataSWR<ImageGenerationTopic[]>(
-      enabled ? [FETCH_GENERATION_TOPICS_KEY, isLogin] : null,
+      enabled ? [FETCH_GENERATION_TOPICS_KEY] : null,
       () => generationTopicService.getAllGenerationTopics(),
       {
         suspense: true,
@@ -231,7 +228,7 @@ export const createGenerationTopicSlice: StateCreator<
     ),
 
   refreshGenerationTopics: async () => {
-    await mutate([FETCH_GENERATION_TOPICS_KEY, true]);
+    await mutate([FETCH_GENERATION_TOPICS_KEY]);
   },
 
   removeGenerationTopic: async (id: string) => {

package/src/hooks/useFetchGenerationTopics.ts

@@ -1,13 +0,0 @@
-import { useGlobalStore } from '@/store/global';
-import { systemStatusSelectors } from '@/store/global/selectors';
-import { useImageStore } from '@/store/image';
-import { useUserStore } from '@/store/user';
-import { authSelectors } from '@/store/user/slices/auth/selectors';
-
-export const useFetchGenerationTopics = () => {
-  const isDBInited = useGlobalStore(systemStatusSelectors.isDBInited);
-  const isLogin = useUserStore(authSelectors.isLogin);
-  const useFetchGenerationTopics = useImageStore((s) => s.useFetchGenerationTopics);
-
-  useFetchGenerationTopics(isDBInited, isLogin);
-};