@lobehub/chat 1.120.6 → 1.121.0

package/packages/model-runtime/src/RouterRuntime/createRuntime.test.ts

@@ -96,7 +96,7 @@ describe('createRouterRuntime', () => {
       });
 
       const runtime = new Runtime();
-      const models = await runtime['getModels']({
+      const models = await runtime['getRouterMatchModels']({
         id: 'test',
         models: ['model-1', 'model-2'],
         runtime: mockRuntime,
@@ -105,7 +105,7 @@ describe('createRouterRuntime', () => {
       expect(models).toEqual(['model-1', 'model-2']);
     });
 
-    it('should call and cache asynchronous models function', async () => {
+    it('should call asynchronous models function', async () => {
       const mockRuntime = {
         chat: vi.fn(),
       } as unknown as LobeRuntimeAI;
@@ -131,14 +131,9 @@ describe('createRouterRuntime', () => {
         runtime: mockRuntime,
       };
 
-      // First call
-      const models1 = await runtime['getModels'](runtimeItem);
-      expect(models1).toEqual(['async-model-1', 'async-model-2']);
-      expect(mockModelsFunction).toHaveBeenCalledTimes(1);
-
-      // Second call should use cache
-      const models2 = await runtime['getModels'](runtimeItem);
-      expect(models2).toEqual(['async-model-1', 'async-model-2']);
+      // Call the function
+      const models = await runtime['getRouterMatchModels'](runtimeItem);
+      expect(models).toEqual(['async-model-1', 'async-model-2']);
       expect(mockModelsFunction).toHaveBeenCalledTimes(1);
     });
 
@@ -159,7 +154,7 @@ describe('createRouterRuntime', () => {
       });
 
       const runtime = new Runtime();
-      const models = await runtime['getModels']({
+      const models = await runtime['getRouterMatchModels']({
         id: 'test',
         runtime: mockRuntime,
       });
@@ -455,84 +450,4 @@ describe('createRouterRuntime', () => {
       expect(mockTextToSpeech).toHaveBeenCalledWith(payload, options);
     });
   });
-
-  describe('clearModelCache method', () => {
-    it('should clear specific runtime cache when runtimeId provided', async () => {
-      const mockModelsFunction = vi.fn().mockResolvedValue(['model-1']);
-
-      const Runtime = createRouterRuntime({
-        id: 'test-runtime',
-        routers: [
-          {
-            apiType: 'openai',
-            options: {},
-            runtime: vi.fn() as any,
-            models: mockModelsFunction,
-          },
-        ],
-      });
-
-      const runtime = new Runtime();
-      const runtimeItem = {
-        id: 'test-id',
-        models: mockModelsFunction,
-        runtime: {} as any,
-      };
-
-      // Build cache
-      await runtime['getModels'](runtimeItem);
-      expect(mockModelsFunction).toHaveBeenCalledTimes(1);
-
-      // Clear specific cache
-      runtime.clearModelCache('test-id');
-
-      // Should call function again
-      await runtime['getModels'](runtimeItem);
-      expect(mockModelsFunction).toHaveBeenCalledTimes(2);
-    });
-
-    it('should clear all cache when no runtimeId provided', async () => {
-      const mockModelsFunction1 = vi.fn().mockResolvedValue(['model-1']);
-      const mockModelsFunction2 = vi.fn().mockResolvedValue(['model-2']);
-
-      const Runtime = createRouterRuntime({
-        id: 'test-runtime',
-        routers: [
-          {
-            apiType: 'openai',
-            options: {},
-            runtime: vi.fn() as any,
-            models: mockModelsFunction1,
-          },
-        ],
-      });
-
-      const runtime = new Runtime();
-      const runtimeItem1 = {
-        id: 'test-id-1',
-        models: mockModelsFunction1,
-        runtime: {} as any,
-      };
-      const runtimeItem2 = {
-        id: 'test-id-2',
-        models: mockModelsFunction2,
-        runtime: {} as any,
-      };
-
-      // Build cache for both items
-      await runtime['getModels'](runtimeItem1);
-      await runtime['getModels'](runtimeItem2);
-      expect(mockModelsFunction1).toHaveBeenCalledTimes(1);
-      expect(mockModelsFunction2).toHaveBeenCalledTimes(1);
-
-      // Clear all cache
-      runtime.clearModelCache();
-
-      // Should call functions again
-      await runtime['getModels'](runtimeItem1);
-      await runtime['getModels'](runtimeItem2);
-      expect(mockModelsFunction1).toHaveBeenCalledTimes(2);
-      expect(mockModelsFunction2).toHaveBeenCalledTimes(2);
-    });
-  });
 });

package/packages/model-runtime/src/RouterRuntime/createRuntime.ts

@@ -117,7 +117,6 @@ export const createRouterRuntime = ({
   return class UniformRuntime implements LobeRuntimeAI {
     private _runtimes: RuntimeItem[];
     private _options: ClientOptions & Record<string, any>;
-    private _modelCache = new Map<string, string[]>();
 
     constructor(options: ClientOptions & Record<string, any> = {}) {
       const _options = {
@@ -143,30 +142,21 @@ export const createRouterRuntime = ({
       this._options = _options;
     }
 
-    // Get runtime's models list, supporting both synchronous arrays and asynchronous functions with caching
-    private async getModels(runtimeItem: RuntimeItem): Promise<string[]> {
-      const cacheKey = runtimeItem.id;
-
-      // If it's a synchronous array, return directly without caching
+    // Get runtime's models list, supporting both synchronous arrays and asynchronous functions
+    private async getRouterMatchModels(runtimeItem: RuntimeItem): Promise<string[]> {
+      // If it's a synchronous array, return directly
       if (typeof runtimeItem.models !== 'function') {
         return runtimeItem.models || [];
       }
 
-      // Check cache
-      if (this._modelCache.has(cacheKey)) {
-        return this._modelCache.get(cacheKey)!;
-      }
-
-      // Get model list and cache result
-      const models = await runtimeItem.models();
-      this._modelCache.set(cacheKey, models);
-      return models;
+      // Get model list
+      return await runtimeItem.models();
     }
 
     // Check if it can match a specific model, otherwise default to using the last runtime
     async getRuntimeByModel(model: string) {
       for (const runtimeItem of this._runtimes) {
-        const models = await this.getModels(runtimeItem);
+        const models = await this.getRouterMatchModels(runtimeItem);
         if (models.includes(model)) {
           return runtimeItem.runtime;
         }
@@ -226,17 +216,5 @@ export const createRouterRuntime = ({
 
       return runtime.textToSpeech!(payload, options);
     }
-
-    /**
-     * Clear model list cache, forcing reload on next access
-     * @param runtimeId - Optional, specify to clear cache for a specific runtime, omit to clear all caches
-     */
-    clearModelCache(runtimeId?: string) {
-      if (runtimeId) {
-        this._modelCache.delete(runtimeId);
-      } else {
-        this._modelCache.clear();
-      }
-    }
   };
 };

package/packages/model-runtime/src/openrouter/index.ts

@@ -71,29 +71,32 @@ export const LobeOpenRouterAI = createOpenAICompatibleRuntime({
 
     // 处理前端获取的模型信息，转换为标准格式
     const formattedModels = modelList.map((model) => {
+      const { endpoint } = model;
+      const endpointModel = endpoint?.model;
+
       const displayName = model.slug?.toLowerCase().includes('deepseek')
         ? (model.name ?? model.slug)
         : (model.short_name ?? model.name ?? model.slug);
 
+      const inputModalities = endpointModel?.input_modalities || model.input_modalities;
+
       return {
-        contextWindowTokens: model.context_length,
-        description: model.description,
+        contextWindowTokens: endpoint?.context_length || model.context_length,
+        description: endpointModel?.description || model.description,
         displayName,
-        functionCall: model.endpoint?.supports_tool_parameters || false,
-        id: model.slug,
+        functionCall: endpoint?.supports_tool_parameters || false,
+        id: endpoint?.model_variant_slug || model.slug,
         maxOutput:
-          typeof model.endpoint?.max_completion_tokens === 'number'
-            ? model.endpoint.max_completion_tokens
+          typeof endpoint?.max_completion_tokens === 'number'
+            ? endpoint.max_completion_tokens
             : undefined,
         pricing: {
-          input: formatPrice(model.endpoint?.pricing?.prompt),
-          output: formatPrice(model.endpoint?.pricing?.completion),
+          input: formatPrice(endpoint?.pricing?.prompt),
+          output: formatPrice(endpoint?.pricing?.completion),
         },
-        reasoning: model.endpoint?.supports_reasoning || false,
+        reasoning: endpoint?.supports_reasoning || false,
         releasedAt: new Date(model.created_at).toISOString().split('T')[0],
-        vision:
-          (Array.isArray(model.input_modalities) && model.input_modalities.includes('image')) ||
-          false,
+        vision: Array.isArray(inputModalities) && inputModalities.includes('image'),
       };
     });
 

package/packages/model-runtime/src/openrouter/type.ts

@@ -19,11 +19,21 @@ export interface OpenRouterModelCard {
 }
 
 interface OpenRouterModelEndpoint {
+  context_length?: number;
   max_completion_tokens: number | null;
+  model?: {
+    description?: string;
+    input_modalities?: string[];
+    name?: string;
+    short_name?: string;
+    slug: string;
+  };
+  model_variant_slug?: string;
   pricing: ModelPricing;
   supported_parameters: string[];
   supports_reasoning?: boolean;
   supports_tool_parameters?: boolean;
+  variant?: 'free' | 'standard' | 'unknown';
 }
 
 interface OpenRouterOpenAIReasoning {

package/packages/model-runtime/src/utils/modelParse.test.ts

@@ -758,4 +758,70 @@ describe('modelParse', () => {
       expect(modelConfigKeys.sort()).toEqual(providerDetectionKeys.sort());
     });
   });
+
+  describe('displayName processing', () => {
+    it('should replace "Gemini 2.5 Flash Image Preview" with "Nano Banana"', async () => {
+      const modelList = [
+        {
+          id: 'gemini-2.5-flash-image-preview',
+          displayName: 'Gemini 2.5 Flash Image Preview',
+        },
+        {
+          id: 'some-other-model',
+          displayName: 'Some Other Model',
+        },
+        {
+          id: 'partial-gemini-model',
+          displayName: 'Custom Gemini 2.5 Flash Image Preview Enhanced',
+        },
+        {
+          id: 'gemini-free-model',
+          displayName: 'Gemini 2.5 Flash Image Preview (free)',
+        },
+      ];
+
+      const result = await processModelList(modelList, MODEL_LIST_CONFIGS.google);
+
+      expect(result).toHaveLength(4);
+
+      // First model should have "Nano Banana" as displayName
+      const geminiModel = result.find((m) => m.id === 'gemini-2.5-flash-image-preview');
+      expect(geminiModel?.displayName).toBe('Nano Banana');
+
+      // Second model should keep original displayName
+      const otherModel = result.find((m) => m.id === 'some-other-model');
+      expect(otherModel?.displayName).toBe('Some Other Model');
+
+      // Third model (partial match) should replace only the matching part
+      const partialModel = result.find((m) => m.id === 'partial-gemini-model');
+      expect(partialModel?.displayName).toBe('Custom Nano Banana Enhanced');
+
+      // Fourth model should preserve the (free) suffix
+      const freeModel = result.find((m) => m.id === 'gemini-free-model');
+      expect(freeModel?.displayName).toBe('Nano Banana (free)');
+    });
+
+    it('should keep original displayName when not matching Gemini 2.5 Flash Image Preview', async () => {
+      const modelList = [
+        {
+          id: 'gpt-4',
+          displayName: 'GPT-4',
+        },
+        {
+          id: 'gemini-pro',
+          displayName: 'Gemini Pro',
+        },
+      ];
+
+      const result = await processModelList(modelList, MODEL_LIST_CONFIGS.google);
+
+      expect(result).toHaveLength(2);
+
+      const gptModel = result.find((m) => m.id === 'gpt-4');
+      expect(gptModel?.displayName).toBe('GPT-4');
+
+      const geminiProModel = result.find((m) => m.id === 'gemini-pro');
+      expect(geminiProModel?.displayName).toBe('Gemini Pro');
+    });
+  });
 });

package/packages/model-runtime/src/utils/modelParse.ts

@@ -264,6 +264,20 @@ const processReleasedAt = (model: any, knownModel?: any): string | undefined =>
   return model.releasedAt ?? knownModel?.releasedAt ?? undefined;
 };
 
+/**
+ * 处理模型显示名称
+ * @param displayName 原始显示名称
+ * @returns 处理后的显示名称
+ */
+const processDisplayName = (displayName: string): string => {
+  // 如果包含 "Gemini 2.5 Flash Image Preview"，替换对应部分为 "Nano Banana"
+  if (displayName.includes('Gemini 2.5 Flash Image Preview')) {
+    return displayName.replace('Gemini 2.5 Flash Image Preview', 'Nano Banana');
+  }
+
+  return displayName;
+};
+
 /**
  * 处理模型卡片的通用逻辑
  */
@@ -331,9 +345,7 @@ const processModelCard = (
   return {
     contextWindowTokens: model.contextWindowTokens ?? knownModel?.contextWindowTokens ?? undefined,
     description: model.description ?? knownModel?.description ?? '',
-    displayName: (model.displayName ?? knownModel?.displayName ?? model.id)
-      .replaceAll(/\s*[(（][^)）]*[)）]\s*/g, '')
-      .trim(), // 去除括号内容
+    displayName: processDisplayName(model.displayName ?? knownModel?.displayName ?? model.id),
     enabled: model?.enabled || false,
     functionCall:
       model.functionCall ??

package/packages/model-runtime/src/utils/postProcessModelList.ts

@@ -5,6 +5,7 @@ import type { ChatModelCard } from '@/types/llm';
 // Whitelist for automatic image model generation
 export const IMAGE_GENERATION_MODEL_WHITELIST = [
   'gemini-2.5-flash-image-preview',
+  'gemini-2.5-flash-image-preview:free',
   // More models can be added in the future
 ] as const;
 

package/packages/utils/src/detectChinese.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { containsChinese } from './detectChinese';
+
+describe('containsChinese', () => {
+  it('should return true for text containing Chinese characters', () => {
+    expect(containsChinese('你好世界')).toBe(true);
+    expect(containsChinese('Hello 世界')).toBe(true);
+    expect(containsChinese('测试 test')).toBe(true);
+    expect(containsChinese('这是一个测试')).toBe(true);
+  });
+
+  it('should return false for text without Chinese characters', () => {
+    expect(containsChinese('Hello World')).toBe(false);
+    expect(containsChinese('123456')).toBe(false);
+    expect(containsChinese('!@#$%^&*()')).toBe(false);
+    expect(containsChinese('')).toBe(false);
+    expect(containsChinese('English only text')).toBe(false);
+  });
+
+  it('should handle mixed content correctly', () => {
+    expect(containsChinese('Hello 中国')).toBe(true);
+    expect(containsChinese('English and 数字 123')).toBe(true);
+    expect(containsChinese('Japanese こんにちは and English')).toBe(false);
+    expect(containsChinese('Korean 안녕하세요 and English')).toBe(false);
+  });
+
+  it('should detect extended Chinese character ranges', () => {
+    // Test CJK Unified Ideographs Extension A (U+3400-U+4DBF)
+    expect(containsChinese('㐀㑇㒯')).toBe(true);
+    // Test CJK Compatibility Ideographs (U+F900-U+FAFF)
+    expect(containsChinese('豈更車')).toBe(true);
+    // Test traditional Chinese characters
+    expect(containsChinese('繁體中文')).toBe(true);
+    expect(containsChinese('學習語言')).toBe(true);
+  });
+});

package/packages/utils/src/detectChinese.ts

@@ -0,0 +1,12 @@
+/**
+ * Detect if text contains Chinese characters
+ * @param text - The text to check
+ * @returns true if text contains Chinese characters, false otherwise
+ */
+export const containsChinese = (text: string): boolean => {
+  // Enhanced regex to cover more Chinese character ranges:
+  // \u4e00-\u9fa5: CJK Unified Ideographs (basic)
+  // \u3400-\u4dbf: CJK Unified Ideographs Extension A
+  // \uf900-\ufaff: CJK Compatibility Ideographs
+  return /[\u3400-\u4DBF\u4E00-\u9FA5\uF900-\uFAFF]/.test(text);
+};

package/packages/utils/src/index.ts

@@ -1,4 +1,5 @@
 export * from './client/cookie';
+export * from './detectChinese';
 export * from './format';
 export * from './imageToBase64';
 export * from './parseModels';

package/src/app/[variants]/(main)/chat/(workspace)/@conversation/features/ChatInput/Desktop/TextArea.test.tsx

@@ -7,10 +7,27 @@ import { useUserStore } from '@/store/user';
 
 import InputArea from './TextArea';
 
+let sendMessageMock: () => Promise<void>;
+
+// Mock the useSendMessage hook to return our mock function
+vi.mock('@/features/ChatInput/useSend', () => ({
+  useSendMessage: () => ({
+    send: sendMessageMock,
+    canSend: true,
+  }),
+}));
+
+// Mock the Chinese warning hook to always allow sending
+vi.mock('@/hooks/useGeminiChineseWarning', () => ({
+  useGeminiChineseWarning: () => () => Promise.resolve(true),
+}));
+
 let onSendMock: () => void;
 
 beforeEach(() => {
   onSendMock = vi.fn();
+  sendMessageMock = vi.fn().mockResolvedValue(undefined);
+  vi.clearAllMocks();
 });
 
 describe('<InputArea />', () => {
@@ -194,9 +211,8 @@ describe('<InputArea />', () => {
 
   describe('message sending behavior', () => {
     it('does not send message when loading or shift key is pressed', () => {
-      const sendMessageMock = vi.fn();
       act(() => {
-        useChatStore.setState({ chatLoadingIds: ['123'], sendMessage: sendMessageMock });
+        useChatStore.setState({ chatLoadingIds: ['123'] });
       });
 
       render(<InputArea onSend={onSendMock} />);
@@ -206,13 +222,11 @@ describe('<InputArea />', () => {
       expect(sendMessageMock).not.toHaveBeenCalled();
     });
 
-    it('sends message on Enter press when not loading and no shift key', () => {
-      const sendMessageMock = vi.fn();
+    it('sends message on Enter press when not loading and no shift key', async () => {
       act(() => {
         useChatStore.setState({
           chatLoadingIds: [],
           inputMessage: 'abc',
-          sendMessage: sendMessageMock,
         });
       });
 
@@ -221,17 +235,18 @@ describe('<InputArea />', () => {
       fireEvent.change(textArea, { target: { value: 'Test message' } });
 
       fireEvent.keyDown(textArea, { code: 'Enter', key: 'Enter' });
-      expect(sendMessageMock).toHaveBeenCalled();
+
+      await vi.waitFor(() => {
+        expect(sendMessageMock).toHaveBeenCalled();
+      });
     });
 
     describe('metaKey behavior for sending messages', () => {
-      it('windows: sends message on ctrl + enter when useCmdEnterToSend is true', () => {
-        const sendMessageMock = vi.fn();
+      it('windows: sends message on ctrl + enter when useCmdEnterToSend is true', async () => {
         act(() => {
           useChatStore.setState({
             chatLoadingIds: [],
             inputMessage: '123',
-            sendMessage: sendMessageMock,
           });
           useUserStore.getState().updatePreference({ useCmdEnterToSend: true });
         });
@@ -240,17 +255,18 @@ describe('<InputArea />', () => {
         const textArea = screen.getByRole('textbox');
 
         fireEvent.keyDown(textArea, { code: 'Enter', ctrlKey: true, key: 'Enter' });
-        expect(sendMessageMock).toHaveBeenCalled();
+
+        await vi.waitFor(() => {
+          expect(sendMessageMock).toHaveBeenCalled();
+        });
       });
 
       it('windows: inserts a new line on ctrl + enter when useCmdEnterToSend is false', () => {
-        const sendMessageMock = vi.fn();
         const updateInputMessageMock = vi.fn();
         act(() => {
           useChatStore.setState({
             chatLoadingIds: [],
             inputMessage: 'Test',
-            sendMessage: sendMessageMock,
             updateInputMessage: updateInputMessageMock,
           });
           useUserStore.getState().updatePreference({ useCmdEnterToSend: false });
@@ -264,17 +280,15 @@ describe('<InputArea />', () => {
         expect(sendMessageMock).not.toHaveBeenCalled(); // sendMessage should not be called
       });
 
-      it('macOS: sends message on cmd + enter when useCmdEnterToSend is true', () => {
+      it('macOS: sends message on cmd + enter when useCmdEnterToSend is true', async () => {
         vi.stubGlobal('navigator', {
           userAgent:
             'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
         });
-        const sendMessageMock = vi.fn();
         act(() => {
           useChatStore.setState({
             chatLoadingIds: [],
             inputMessage: '123',
-            sendMessage: sendMessageMock,
           });
           useUserStore.getState().updatePreference({ useCmdEnterToSend: true });
         });
@@ -283,7 +297,10 @@ describe('<InputArea />', () => {
         const textArea = screen.getByRole('textbox');
 
         fireEvent.keyDown(textArea, { code: 'Enter', key: 'Enter', metaKey: true });
-        expect(sendMessageMock).toHaveBeenCalled();
+
+        await vi.waitFor(() => {
+          expect(sendMessageMock).toHaveBeenCalled();
+        });
         vi.restoreAllMocks();
       });
 
@@ -292,13 +309,11 @@ describe('<InputArea />', () => {
           userAgent:
             'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
         });
-        const sendMessageMock = vi.fn();
         const updateInputMessageMock = vi.fn();
         act(() => {
           useChatStore.setState({
             chatLoadingIds: [],
             inputMessage: 'Test',
-            sendMessage: sendMessageMock,
             updateInputMessage: updateInputMessageMock,
           });
           useUserStore.getState().updatePreference({ useCmdEnterToSend: false });

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

@@ -8,9 +8,11 @@ import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
 
 import { loginRequired } from '@/components/Error/loginRequiredNotification';
+import { useGeminiChineseWarning } from '@/hooks/useGeminiChineseWarning';
 import { useImageStore } from '@/store/image';
 import { createImageSelectors } from '@/store/image/selectors';
 import { useGenerationConfigParam } from '@/store/image/slices/generationConfig/hooks';
+import { imageGenerationConfigSelectors } from '@/store/image/slices/generationConfig/selectors';
 import { useUserStore } from '@/store/user';
 import { authSelectors } from '@/store/user/slices/auth/selectors';
 
@@ -49,13 +51,23 @@ const PromptInput = ({ showTitle = false }: PromptInputProps) => {
   const { value, setValue } = useGenerationConfigParam('prompt');
   const isCreating = useImageStore(createImageSelectors.isCreating);
   const createImage = useImageStore((s) => s.createImage);
+  const currentModel = useImageStore(imageGenerationConfigSelectors.model);
   const isLogin = useUserStore(authSelectors.isLogin);
+  const checkGeminiChineseWarning = useGeminiChineseWarning();
 
   const handleGenerate = async () => {
     if (!isLogin) {
       loginRequired.redirect({ timeout: 2000 });
       return;
     }
+    // Check for Chinese text warning with Gemini model
+    const shouldContinue = await checkGeminiChineseWarning({
+      model: currentModel,
+      prompt: value,
+      scenario: 'image',
+    });
+
+    if (!shouldContinue) return;
 
     await createImage();
   };

package/src/features/ChatInput/useSend.ts

@@ -1,6 +1,7 @@
 import { useAnalytics } from '@lobehub/analytics/react';
 import { useCallback, useMemo } from 'react';
 
+import { useGeminiChineseWarning } from '@/hooks/useGeminiChineseWarning';
 import { getAgentStoreState } from '@/store/agent';
 import { agentSelectors } from '@/store/agent/selectors';
 import { useChatStore } from '@/store/chat';
@@ -20,6 +21,7 @@ export const useSendMessage = () => {
     s.updateInputMessage,
   ]);
   const { analytics } = useAnalytics();
+  const checkGeminiChineseWarning = useGeminiChineseWarning();
 
   const clearChatUploadFileList = useFileStore((s) => s.clearChatUploadFileList);
 
@@ -28,7 +30,7 @@ export const useSendMessage = () => {
 
   const canSend = !isUploadingFiles && !isSendButtonDisabledByMessage;
 
-  const send = useCallback((params: UseSendMessageParams = {}) => {
+  const send = useCallback(async (params: UseSendMessageParams = {}) => {
     const store = useChatStore.getState();
     if (chatSelectors.isAIGenerating(store)) return;
 
@@ -45,6 +47,17 @@ export const useSendMessage = () => {
     // if there is no message and no image, then we should not send the message
     if (!store.inputMessage && fileList.length === 0) return;
 
+    // Check for Chinese text warning with Gemini model
+    const agentStore = getAgentStoreState();
+    const currentModel = agentSelectors.currentAgentModel(agentStore);
+    const shouldContinue = await checkGeminiChineseWarning({
+      model: currentModel,
+      prompt: store.inputMessage,
+      scenario: 'chat',
+    });
+
+    if (!shouldContinue) return;
+
     sendMessage({
       files: fileList,
       message: store.inputMessage,
@@ -56,7 +69,6 @@ export const useSendMessage = () => {
 
     // 获取分析数据
     const userStore = getUserStoreState();
-    const agentStore = getAgentStoreState();
 
     // 直接使用现有数据结构判断消息类型
     const hasImages = fileList.some((file) => file.file?.type?.startsWith('image'));