@lobehub/chat 1.105.6 → 1.106.1

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # 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>
+
+#### ✨ Features
+
+- **misc**: Add support for Okta Authentication.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Add support for Okta Authentication, closes [#8547](https://github.com/lobehub/lobe-chat/issues/8547) ([67abdfe](https://github.com/lobehub/lobe-chat/commit/67abdfe))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.105.6](https://github.com/lobehub/lobe-chat/compare/v1.105.5...v1.105.6)
 
 <sup>Released on **2025-07-29**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Support Minimax T2I models."
+      ]
+    },
+    "date": "2025-07-29",
+    "version": "1.106.1"
+  },
+  {
+    "children": {
+      "features": [
+        "Add support for Okta Authentication."
+      ]
+    },
+    "date": "2025-07-29",
+    "version": "1.106.0"
+  },
   {
     "children": {
       "improvements": [

package/docs/self-hosting/advanced/auth/next-auth/okta.mdx

@@ -0,0 +1,65 @@
+---
+title: Configure Okta Identity Verification Service for LobeChat
+description: >-
+  Learn how to configure Okta Identity Verification Service for LobeChat for your organization, including creating applications, adding users, and configuring environment variables.
+
+tags:
+  - Okta
+  - Identity Verification
+  - Single Sign-On
+  - Environment Variables
+  - User Management
+  - SSO Integrations
+  - Social Login
+---
+
+# Configure Okta Identity Verification Service
+
+<Steps>
+  ### Create Okta Application
+
+  Register and log in to [Okta][okta-client-page], open the "Applications" subtab in the left navigation bar, and click "Applications" to switch to the application management interface. click "Create App Integration" in the upper left corner to create an application.
+
+  Select "OIDC - OpenID Connect" in Sign-In Method and then select "Web Application" in Application Type.
+
+  Fill in the following settings:
+
+  | Setting Name           | Description                                                                                                  | Sample Information                            |
+  | ---------------------- | ------------------------------------------------------------------------------------------------------------ | --------------------------------------------- |
+  | App Integration Name   | The Application Name your users will see                                                                     | LobeChat Instance                             |
+  | Sign-in redirect URIs  | Okta sends the authentication response and ID token for the user's sign-in request to these URIs             | (http(s)://your-domain/api/auth/callback/okta |
+  | Sign-out redirect URIs | After your application contacts Okta to close the user session, Okta redirects the user to one of these URIs | (http(s)://your-domain                        |
+
+  <Callout type={'important'}>
+    You can fill in or modify all the fields after deployment, but make sure the filled URL is
+    consistent with the deployed URL.
+  </Callout>
+
+  ### Add Users
+
+  Click on the "Assignments" in the top navigation bar to enter the user management interface, where you can create or assign users in your organization to log in to LobeChat.
+
+  ### Configure Environment Variables
+
+  When deploying LobeChat, you need to configure the following environment variables:
+
+  | Environment Variable      | Type     | Description                                                                                                                                                                                         |
+  | ------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+  | `NEXT_AUTH_SECRET`        | Required | Key used to encrypt Auth.js session tokens. You can generate a key using the following command: `openssl rand -base64 32`                                                                           |
+  | `NEXT_AUTH_SSO_PROVIDERS` | Required | Select the single sign-on provider for LoboChat. Use `okta` for Okta.                                                                                                                               |
+  | `AUTH_OKTA_ID`            | Required | Client ID of the Okta application                                                                                                                                                                   |
+  | `AUTH_OKTA_SECRET`        | Required | Client Secret of the Okta application                                                                                                                                                               |
+  | `AUTH_OKTA_ISSUER`        | Required | Domain of the Okta application, `https://example.oktapreview.com`                                                                                                                                   |
+  | `NEXTAUTH_URL`            | Optional | The URL is used to specify the callback address for the execution of OAuth authentication in Auth.js. It needs to be set only when the default address is incorrect. `https://example.com/api/auth` |
+
+  <Callout type={'tip'}>
+    You can refer to the related variable details at [📘Environment Variables](/docs/self-hosting/environment-variable/auth#okta).
+  </Callout>
+</Steps>
+
+<Callout>
+  After successful deployment, users will be able to authenticate and use LobeChat using the users
+  configured in Okta.
+</Callout>
+
+[okta-client-page]: https://login.okta.com

package/docs/self-hosting/advanced/auth/next-auth/okta.zh-CN.mdx

@@ -0,0 +1,63 @@
+---
+title: 在 LobeChat 中配置 Okta 身份验证服务 - 详细步骤和环境变量设置
+description: >-
+  学习如何在 LobeChat 中为您的组织配置 Okta 身份验证服务，包括创建应用程序、添加用户和配置环境变量等。
+
+tags:
+  - Okta
+  - 身份验证
+  - 单点登录
+  - 环境变量
+  - 用户管理
+  - SSO 集成
+  - 社交登录
+---
+
+# 配置 Okta 身份验证服务
+
+<Steps>
+  ### 创建 Okta 应用程序
+
+  注册并登录 [Okta][okta-client-page]，打开左侧导航栏中的「Applications」子选项卡，点击「Applications」切换到应用程序管理界面。点击左上角的「Create App Integration」创建应用程序。
+
+  在登录方法中选择「OIDC - OpenID Connect」，然后在应用程序类型中选择「Web Application」。
+
+  填写以下设置：
+
+  | 设置名称                   | 描述                                          | 示例信息                                          |
+  | ---------------------- | ------------------------------------------- | --------------------------------------------- |
+  | App Integration Name   | 您的用户将看到的应用程序名称                              | LobeChat Instance                             |
+  | Sign-in redirect URIs  | Okta 将用户登录请求的身份验证响应和 ID 令牌发送到这些 URI         | (http(s)://your-domain/api/auth/callback/okta |
+  | Sign-out redirect URIs | 您的应用程序联系 Okta 关闭用户会话后，Okta 将用户重定向到这些 URI 之一 | (http(s)://your-domain                        |
+
+  <Callout type={'important'}>
+    您可以在部署后填写或修改所有字段，但请确保填写的 URL 与部署的 URL 一致。
+  </Callout>
+
+  ### 添加用户
+
+  点击顶部导航栏中的「Assignments」进入用户管理界面，您可以在此创建或分配组织中的用户来登录 LobeChat。
+
+  ### 配置环境变量
+
+  在部署 LobeChat 时，您需要配置以下环境变量：
+
+  | 环境变量                      | 类型 | 描述                                                                                   |
+  | ------------------------- | -- | ------------------------------------------------------------------------------------ |
+  | `NEXT_AUTH_SECRET`        | 必选 | 用于加密 Auth.js 会话令牌的密钥。您可以使用以下命令生成密钥：`openssl rand -base64 32`                         |
+  | `NEXT_AUTH_SSO_PROVIDERS` | 必选 | 选择 LoboChat 的单点登录提供商。使用 Okta 请填写 `okta`。                                             |
+  | `AUTH_OKTA_ID`            | 必选 | Okta 应用程序的客户端 ID                                                                     |
+  | `AUTH_OKTA_SECRET`        | 必选 | Okta 应用程序的客户端密钥                                                                      |
+  | `AUTH_OKTA_ISSUER`        | 必选 | Okta 应用程序的域名，`https://example.oktapreview.com`                                       |
+  | `NEXTAUTH_URL`            | 可选 | 该 URL 用于指定 Auth.js 在执行 OAuth 认证时的回调地址。仅当默认地址不正确时才需要设置。`https://example.com/api/auth` |
+
+  <Callout type={'tip'}>
+    您可以在 [📘环境变量](/zh/docs/self-hosting/environment-variables/auth#okta) 查阅相关变量详情。
+  </Callout>
+</Steps>
+
+<Callout>
+  部署成功后，用户将能够使用在 Okta 中配置的用户进行身份验证并使用 LobeChat。
+</Callout>
+
+[okta-client-page]: https://login.okta.com

package/docs/self-hosting/advanced/auth.mdx

@@ -55,6 +55,8 @@ Currently supported identity verification services include:
   <Card href={'/docs/self-hosting/advanced/auth/next-auth/keycloak'} title={'Keycloak'} />
 
   <Card href={'/docs/self-hosting/advanced/auth/next-auth/google'} title={'Google'} />
+
+  <Card href={'/docs/self-hosting/advanced/auth/next-auth/okta'} title={'Okta'} />
 </Cards>
 
 Click on the links to view the corresponding platform's configuration documentation.
@@ -78,6 +80,7 @@ The order corresponds to the display order of the SSO providers.
 | ZITADEL               | `zitadel`               |
 | Keycloak              | `keycloak`              |
 | Google                | `google`                |
+| Okta                  | `okta`                  |
 
 ## Other SSO Providers
 

package/docs/self-hosting/advanced/auth.zh-CN.mdx

@@ -51,6 +51,8 @@ LobeChat 与 Clerk 做了深度集成，能够为用户提供一个更加安全
   <Card href={'/zh/docs/self-hosting/advanced/auth/next-auth/logto'} title={'Logto'} />
 
   <Card href={'/zh/docs/self-hosting/advanced/auth/next-auth/keycloak'} title={'Keycloak'} />
+
+  <Card href={'/zh/docs/self-hosting/advanced/auth/next-auth/okta'} title={'Okta'} />
 </Cards>
 
 点击即可查看对应平台的配置文档。
@@ -73,6 +75,7 @@ LobeChat 与 Clerk 做了深度集成，能够为用户提供一个更加安全
 | Microsoft Entra ID    | `microsoft-entra-id`    |
 | ZITADEL               | `zitadel`               |
 | Keycloak              | `keycloak`              |
+| Okta                  | `okta`                  |
 
 ## 其他 SSO 提供商
 

package/docs/self-hosting/environment-variables/auth.mdx

@@ -249,6 +249,29 @@ LobeChat provides a complete authentication service capability when deployed. Th
 - Default: `-`
 - Example: `https://your-instance-abc123.zitadel.cloud`
 
+### Okta
+
+#### `AUTH_OKTA_ID`
+
+- Type: Required
+- Description: Client ID of the Okta application. This can be found under your application settings in the Okta console.
+- Default: `-`
+- Example: `ac12c950f3ce48c8a45a`
+
+#### `AUTH_OKTA_SECRET`
+
+- Type: Required
+- Description: Client Secret of the Okta application. This can be found under your application settings in the Okta console.
+- Default: `-`
+- Example: `ex1HqvSOOkC5INqo42grOSqNvHoD4p84em1yy5QU7v88IZlaWGywFjYkrkpkSopt`
+
+#### `AUTH_OKTA_ISSUER`
+
+- Type: Required
+- Description: Issuer of the Okta application. This is the URL of the Okta instance -- If branding is set up, it can be your custom domain.
+- Default: `-`
+- Example: `https://your-instance.okta.com`
+
 ### Generic OIDC
 
 #### `AUTH_GENERIC_OIDC_ID`

package/docs/self-hosting/environment-variables/auth.zh-CN.mdx

@@ -245,6 +245,29 @@ LobeChat 在部署时提供了完善的身份验证服务能力，以下是相
 - 默认值：`-`
 - 示例：`https://your-instance-abc123.zitadel.cloud`
 
+### Okta
+
+#### `AUTH_OKTA_ID`
+
+- 类型：必选
+- 描述：Okta 应用程序的 Client ID。您可以在 Okta 控制台的应用程序设置中找到。
+- 默认值：`-`
+- 示例：`ac12c950f3ce48c8a45a`
+
+#### `AUTH_OKTA_SECRET`
+
+- 类型：必选
+- 描述：Okta 应用程序的 Client Secret。您可以在 Okta 控制台的应用程序设置中找到。
+- 默认值：`-`
+- 示例：`ex1HqvSOOkC5INqo42grOSqNvHoD4p84em1yy5QU7v88IZlaWGywFjYkrkpkSopt`
+
+#### `AUTH_OKTA_ISSUER`
+
+- 类型：必选
+- 描述：Okta 应用程序的 OpenID Connect 颁发者（issuer）。这是 Okta 实例的 URL—— 如果设置了品牌化，也可以是您的自定义域名。
+- 默认值：`-`
+- 示例：`https://your-instance.okta.com`
+
 ### Generic OIDC
 
 #### `AUTH_GENERIC_OIDC_ID`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.105.6",
+  "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/libs/next-auth/sso-providers/index.ts

@@ -4,15 +4,16 @@ import Authentik from './authentik';
 import AzureAD from './azure-ad';
 import Casdoor from './casdoor';
 import CloudflareZeroTrust from './cloudflare-zero-trust';
+import Cognito from './cognito';
 import GenericOIDC from './generic-oidc';
 import Github from './github';
 import Google from './google';
 import Keycloak from './keycloak';
 import Logto from './logto';
 import MicrosoftEntraID from './microsoft-entra-id';
+import Okta from './okta';
 import WeChat from './wechat';
 import Zitadel from './zitadel';
-import Cognito from "./cognito";
 
 export const ssoProviders = [
   Auth0,
@@ -29,5 +30,6 @@ export const ssoProviders = [
   WeChat,
   Keycloak,
   Google,
-  Cognito
+  Cognito,
+  Okta,
 ];

package/src/libs/next-auth/sso-providers/okta.ts

@@ -0,0 +1,26 @@
+import Okta from 'next-auth/providers/okta';
+
+import { CommonProviderConfig } from './sso.config';
+
+const provider = {
+  id: 'okta',
+  provider: Okta({
+    ...CommonProviderConfig,
+    authorization: { params: { scope: 'openid email profile' } },
+    clientId: process.env.AUTH_OKTA_ID,
+    clientSecret: process.env.AUTH_OKTA_SECRET,
+    issuer: process.env.AUTH_OKTA_ISSUER,
+    // Remove End
+    profile(profile) {
+      return {
+        email: profile.email,
+        id: profile.sub,
+        image: profile.picture,
+        name: profile.name ?? profile.preferred_username,
+        providerAccountId: profile.sub,
+      };
+    },
+  }),
+};
+
+export default provider;

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);
-};