@lobehub/chat 1.106.0 → 1.106.2

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+### [Version 1.106.2](https://github.com/lobehub/lobe-chat/compare/v1.106.1...v1.106.2)
+
+<sup>Released on **2025-07-29**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix desktop auth redirect url error.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix desktop auth redirect url error, closes [#8597](https://github.com/lobehub/lobe-chat/issues/8597) ([0ed7368](https://github.com/lobehub/lobe-chat/commit/0ed7368))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [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,22 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix desktop auth redirect url error."
+      ]
+    },
+    "date": "2025-07-29",
+    "version": "1.106.2"
+  },
+  {
+    "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.2",
   "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",
@@ -257,7 +257,7 @@
     "semver": "^7.7.2",
     "sharp": "^0.34.3",
     "shiki": "^3.8.1",
-    "stripe": "^16.12.0",
+    "stripe": "^17.7.0",
     "superjson": "^2.2.2",
     "svix": "^1.69.0",
     "swr": "^2.3.4",

package/src/app/(backend)/oidc/callback/desktop/route.ts

@@ -3,9 +3,50 @@ import { NextRequest, NextResponse, after } from 'next/server';
 
 import { OAuthHandoffModel } from '@/database/models/oauthHandoff';
 import { serverDB } from '@/database/server';
+import { correctOIDCUrl } from '@/utils/server/correctOIDCUrl';
 
 const log = debug('lobe-oidc:callback:desktop');
 
+const errorPathname = '/oauth/callback/error';
+
+/**
+ * 安全地构建重定向URL
+ */
+const buildRedirectUrl = (req: NextRequest, pathname: string): URL => {
+  const forwardedHost = req.headers.get('x-forwarded-host');
+  const requestHost = req.headers.get('host');
+  const forwardedProto =
+    req.headers.get('x-forwarded-proto') || req.headers.get('x-forwarded-protocol');
+
+  // 确定实际的主机名，提供后备值
+  const actualHost = forwardedHost || requestHost;
+  const actualProto = forwardedProto || 'https';
+
+  log(
+    'Building redirect URL - host: %s, proto: %s, pathname: %s',
+    actualHost,
+    actualProto,
+    pathname,
+  );
+
+  // 如果主机名仍然无效，使用req.nextUrl作为后备
+  if (!actualHost) {
+    log('Warning: Invalid host detected, using req.nextUrl as fallback');
+    const fallbackUrl = req.nextUrl.clone();
+    fallbackUrl.pathname = pathname;
+    return fallbackUrl;
+  }
+
+  try {
+    return new URL(`${actualProto}://${actualHost}${pathname}`);
+  } catch (error) {
+    log('Error constructing URL, using req.nextUrl as fallback: %O', error);
+    const fallbackUrl = req.nextUrl.clone();
+    fallbackUrl.pathname = pathname;
+    return fallbackUrl;
+  }
+};
+
 export const GET = async (req: NextRequest) => {
   try {
     const searchParams = req.nextUrl.searchParams;
@@ -14,9 +55,11 @@ export const GET = async (req: NextRequest) => {
 
     if (!code || !state || typeof code !== 'string' || typeof state !== 'string') {
       log('Missing code or state in form data');
-      const errorUrl = req.nextUrl.clone();
-      errorUrl.pathname = '/oauth/callback/error';
+
+      const errorUrl = buildRedirectUrl(req, errorPathname);
       errorUrl.searchParams.set('reason', 'invalid_request');
+
+      log('Redirecting to error URL: %s', errorUrl.toString());
       return NextResponse.redirect(errorUrl);
     }
 
@@ -31,9 +74,16 @@ export const GET = async (req: NextRequest) => {
     await authHandoffModel.create({ client, id, payload });
     log('Handoff record created successfully for id: %s', id);
 
-    // Redirect to a generic success page. The desktop app will poll for the result.
-    const successUrl = req.nextUrl.clone();
-    successUrl.pathname = '/oauth/callback/success';
+    const successUrl = buildRedirectUrl(req, '/oauth/callback/success');
+
+    // 添加调试日志
+    log('Request host header: %s', req.headers.get('host'));
+    log('Request x-forwarded-host: %s', req.headers.get('x-forwarded-host'));
+    log('Request x-forwarded-proto: %s', req.headers.get('x-forwarded-proto'));
+    log('Constructed success URL: %s', successUrl.toString());
+
+    const correctedUrl = correctOIDCUrl(req, successUrl);
+    log('Final redirect URL: %s', correctedUrl.toString());
 
     // cleanup expired
     after(async () => {
@@ -42,17 +92,18 @@ export const GET = async (req: NextRequest) => {
       log('Cleaned up %d expired handoff records', cleanedCount);
     });
 
-    return NextResponse.redirect(successUrl);
+    return NextResponse.redirect(correctedUrl);
   } catch (error) {
     log('Error in OIDC callback: %O', error);
-    const errorUrl = req.nextUrl.clone();
-    errorUrl.pathname = '/oauth/callback/error';
+
+    const errorUrl = buildRedirectUrl(req, errorPathname);
     errorUrl.searchParams.set('reason', 'internal_error');
 
     if (error instanceof Error) {
       errorUrl.searchParams.set('errorMessage', error.message);
     }
 
+    log('Redirecting to error URL: %s', errorUrl.toString());
     return NextResponse.redirect(errorUrl);
   }
 };

package/src/app/(backend)/oidc/consent/route.ts

@@ -3,6 +3,7 @@ import { NextRequest, NextResponse } from 'next/server';
 
 import { OIDCService } from '@/server/services/oidc';
 import { getUserAuth } from '@/utils/server/auth';
+import { correctOIDCUrl } from '@/utils/server/correctOIDCUrl';
 
 const log = debug('lobe-oidc:consent');
 
@@ -113,19 +114,15 @@ export async function POST(request: NextRequest) {
     const internalRedirectUrlString = await oidcService.getInteractionResult(uid, result);
     log('OIDC Provider internal redirect URL string: %s', internalRedirectUrlString);
 
-    // // Construct the handoff URL
-    // const handoffUrl = new URL('/oauth/handoff', request.nextUrl.origin);
-    // // Set the original redirect URL as the 'target' query parameter (URL encoded)
-    // handoffUrl.searchParams.set('target', internalRedirectUrlString);
-    //
-    // log('Redirecting to handoff page: %s', handoffUrl.toString());
-    // // Redirect to the handoff page
-    // return NextResponse.redirect(handoffUrl.toString(), {
-    //   headers: request.headers, // Keep original headers if necessary
-    //   status: 303,
-    // });
-
-    return NextResponse.redirect(internalRedirectUrlString, {
+    let finalRedirectUrl;
+    try {
+      finalRedirectUrl = correctOIDCUrl(request, new URL(internalRedirectUrlString));
+    } catch {
+      finalRedirectUrl = new URL(internalRedirectUrlString);
+      log('Warning: Could not parse redirect URL, using as-is: %s', internalRedirectUrlString);
+    }
+
+    return NextResponse.redirect(finalRedirectUrl, {
       headers: request.headers,
       status: 303,
     });

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/utils/server/correctOIDCUrl.ts

@@ -0,0 +1,61 @@
+import debug from 'debug';
+import { NextRequest } from 'next/server';
+
+const log = debug('lobe-oidc:correctOIDCUrl');
+
+/**
+ * 修复 OIDC 重定向 URL 在代理环境下的问题
+ * @param req - Next.js 请求对象
+ * @param url - 要修复的 URL 对象
+ * @returns 修复后的 URL 对象
+ */
+export const correctOIDCUrl = (req: NextRequest, url: URL): URL => {
+  const requestHost = req.headers.get('host');
+  const forwardedHost = req.headers.get('x-forwarded-host');
+  const forwardedProto =
+    req.headers.get('x-forwarded-proto') || req.headers.get('x-forwarded-protocol');
+
+  log('Input URL: %s', url.toString());
+  log(
+    'Request headers - host: %s, x-forwarded-host: %s, x-forwarded-proto: %s',
+    requestHost,
+    forwardedHost,
+    forwardedProto,
+  );
+
+  // 确定实际的主机名和协议，提供后备值
+  const actualHost = forwardedHost || requestHost;
+  const actualProto = forwardedProto || (url.protocol === 'https:' ? 'https' : 'http');
+
+  // 如果无法确定有效的主机名，直接返回原URL
+  if (!actualHost || actualHost === 'null') {
+    log('Warning: Cannot determine valid host, returning original URL');
+    return url;
+  }
+
+  // 如果 URL 指向本地地址，或者主机名与实际请求主机不匹配，则修正 URL
+  const needsCorrection =
+    url.hostname === 'localhost' ||
+    url.hostname === '127.0.0.1' ||
+    url.hostname === '0.0.0.0' ||
+    url.hostname !== actualHost;
+
+  if (needsCorrection) {
+    log('URL needs correction. Original hostname: %s, correcting to: %s', url.hostname, actualHost);
+
+    try {
+      const correctedUrl = new URL(url.toString());
+      correctedUrl.protocol = actualProto + ':';
+      correctedUrl.host = actualHost;
+
+      log('Corrected URL: %s', correctedUrl.toString());
+      return correctedUrl;
+    } catch (error) {
+      log('Error creating corrected URL, returning original: %O', error);
+      return url;
+    }
+  }
+
+  log('URL does not need correction, returning original: %s', url.toString());
+  return url;
+};

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