@lobehub/lobehub 2.0.0-next.101 → 2.0.0-next.103

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

@@ -31,6 +31,7 @@ export { LobeQwenAI } from './providers/qwen';
 export { LobeStepfunAI } from './providers/stepfun';
 export { LobeTogetherAI } from './providers/togetherai';
 export { LobeVolcengineAI } from './providers/volcengine';
+export { LobeZenMuxAI } from './providers/zenmux';
 export { LobeZeroOneAI } from './providers/zeroone';
 export { LobeZhipuAI } from './providers/zhipu';
 export * from './types';
@@ -40,4 +41,3 @@ export { AgentRuntimeError } from './utils/createError';
 export { getModelPropertyWithFallback } from './utils/getFallbackModelProperty';
 export { getModelPricing } from './utils/getModelPricing';
 export { parseDataUri } from './utils/uriParser';
-

package/packages/model-runtime/src/providers/google/createImage.ts

@@ -147,6 +147,7 @@ async function generateImageByChatModel(
       ? {
           imageConfig: {
             aspectRatio: params.aspectRatio,
+            imageSize: params.resolution,
           },
         }
       : {}),

package/packages/model-runtime/src/providers/google/index.ts

@@ -38,6 +38,8 @@ const modelsWithModalities = new Set([
   'gemini-2.0-flash-preview-image-generation',
   'gemini-2.5-flash-image-preview',
   'gemini-2.5-flash-image',
+  'gemini-3-pro-image-preview',
+  'nano-banana-pro-preview',
 ]);
 
 const modelsDisableInstuction = new Set([
@@ -51,6 +53,11 @@ const modelsDisableInstuction = new Set([
   'gemma-3-12b-it',
   'gemma-3-27b-it',
   'gemma-3n-e4b-it',
+  // ZenMux
+  'google/gemini-2.5-flash-image-free',
+  'google/gemini-2.5-flash-image',
+  'google/gemini-3-pro-image-preview-free',
+  'google/gemini-3-pro-image-preview',
 ]);
 
 const PRO_THINKING_MIN = 128;
@@ -203,7 +210,10 @@ export class LobeGoogleAI implements LobeRuntimeAI {
         includeThoughts:
           (!!thinkingBudget ||
             !!thinkingLevel ||
-            (model && (model.includes('-3-pro-image') || model.includes('thinking')))) &&
+            (model &&
+              (model.includes('-3-pro-image') ||
+                model.includes('nano-banana-pro') ||
+                model.includes('thinking')))) &&
           resolvedThinkingBudget !== 0
             ? true
             : undefined,

package/packages/model-runtime/src/providers/zenmux/index.test.ts

@@ -0,0 +1,320 @@
+// @vitest-environment node
+import { ModelProvider } from 'model-bank';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import * as modelParseModule from '../../utils/modelParse';
+import { LobeZenMuxAI, params } from './index';
+
+// Mock external dependencies
+vi.mock('../../utils/modelParse');
+
+// Mock console methods
+vi.spyOn(console, 'error').mockImplementation(() => {});
+vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+describe('ZenMux Runtime', () => {
+  let mockFetch: Mock;
+  let mockProcessMultiProviderModelList: Mock;
+  let mockDetectModelProvider: Mock;
+
+  beforeEach(() => {
+    // Setup fetch mock
+    mockFetch = vi.fn();
+    global.fetch = mockFetch;
+
+    // Setup utility function mocks
+    mockProcessMultiProviderModelList = vi.mocked(modelParseModule.processMultiProviderModelList);
+    mockDetectModelProvider = vi.mocked(modelParseModule.detectModelProvider);
+
+    // Clear environment variables
+    delete process.env.DEBUG_ZENMUX_CHAT_COMPLETION;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    delete process.env.DEBUG_ZENMUX_CHAT_COMPLETION;
+  });
+
+  describe('Debug Configuration', () => {
+    it('should return false when DEBUG_ZENMUX_CHAT_COMPLETION is not set', () => {
+      delete process.env.DEBUG_ZENMUX_CHAT_COMPLETION;
+      const debugResult = process.env.DEBUG_ZENMUX_CHAT_COMPLETION === '1';
+      expect(debugResult).toBe(false);
+    });
+
+    it('should return true when DEBUG_ZENMUX_CHAT_COMPLETION is set to 1', () => {
+      process.env.DEBUG_ZENMUX_CHAT_COMPLETION = '1';
+      const debugResult = process.env.DEBUG_ZENMUX_CHAT_COMPLETION === '1';
+      expect(debugResult).toBe(true);
+    });
+  });
+
+  describe('LobeZenMuxAI - custom features', () => {
+    describe('Params Export', () => {
+      it('should export params object', () => {
+        expect(params).toBeDefined();
+        expect(params.id).toBe('zenmux');
+      });
+
+      it('should have routers configuration', () => {
+        expect(params.routers).toBeDefined();
+        expect(typeof params.routers).toBe('function');
+      });
+
+      it('should have models function', () => {
+        expect(params.models).toBeDefined();
+        expect(typeof params.models).toBe('function');
+      });
+
+      it('should have correct provider ID', () => {
+        expect(params.id).toBe(ModelProvider.ZenMux);
+      });
+
+      it('should have chatCompletion handlePayload function', () => {
+        expect(params.chatCompletion).toBeDefined();
+        expect(params.chatCompletion?.handlePayload).toBeDefined();
+        expect(typeof params.chatCompletion?.handlePayload).toBe('function');
+      });
+    });
+
+    describe('ChatCompletion HandlePayload', () => {
+      it('should map reasoning_effort to reasoning.effort', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          reasoning_effort: 'high' as const,
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeDefined();
+        expect(result?.reasoning?.effort).toBe('high');
+        expect(result?.reasoning_effort).toBeUndefined();
+      });
+
+      it('should map thinking.budget_tokens to reasoning.max_tokens', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          thinking: { budget_tokens: 2048, type: 'enabled' as const },
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeDefined();
+        expect(result?.reasoning?.max_tokens).toBe(2048);
+        expect(result?.thinking).toBeUndefined();
+      });
+
+      it('should map thinking.type=enabled to reasoning.enabled=true', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          thinking: { budget_tokens: 1024, type: 'enabled' as const },
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeDefined();
+        expect(result?.reasoning?.enabled).toBe(true);
+        expect(result?.thinking).toBeUndefined();
+      });
+
+      it('should not set reasoning.enabled when thinking.type=disabled', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          thinking: { budget_tokens: 1024, type: 'disabled' as const },
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        // When thinking.type is 'disabled', max_tokens should be mapped and enabled should be false
+        expect(result?.reasoning?.max_tokens).toBe(1024);
+        expect(result?.reasoning?.enabled).toBe(false);
+      });
+
+      it('should map both reasoning_effort and thinking.budget_tokens together', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          reasoning_effort: 'high' as const,
+          thinking: { budget_tokens: 2048, type: 'enabled' as const },
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeDefined();
+        expect(result?.reasoning?.effort).toBe('high');
+        expect(result?.reasoning?.max_tokens).toBe(2048);
+      });
+
+      it('should preserve existing reasoning properties', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          reasoning: { summary: 'auto' },
+          reasoning_effort: 'medium' as const,
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeDefined();
+        expect(result?.reasoning?.summary).toBe('auto');
+        expect(result?.reasoning?.effort).toBe('medium');
+      });
+
+      it('should not include reasoning when no reasoning-related properties', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          temperature: 0.7,
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.reasoning).toBeUndefined();
+      });
+
+      it('should preserve other payload properties', () => {
+        const payload = {
+          model: 'gpt-4o',
+          messages: [],
+          temperature: 0.7,
+          top_p: 0.9,
+          max_tokens: 1024,
+          reasoning_effort: 'high' as const,
+        } as any;
+
+        const result = params.chatCompletion?.handlePayload?.(payload);
+
+        expect(result).toBeDefined();
+        expect(result?.temperature).toBe(0.7);
+        expect(result?.top_p).toBe(0.9);
+        expect(result?.max_tokens).toBe(1024);
+        expect(result?.reasoning?.effort).toBe('high');
+      });
+    });
+
+    describe('Routers Configuration', () => {
+      it('should configure routers with correct endpoints', () => {
+        const mockOptions = { baseURL: 'https://zenmux.ai/api/v1' };
+        const routers = params.routers(mockOptions);
+
+        expect(routers).toBeDefined();
+        expect(Array.isArray(routers)).toBe(true);
+
+        // Check anthropic router
+        const anthropicRouter = routers.find((r) => r.apiType === 'anthropic');
+        expect(anthropicRouter).toBeDefined();
+        expect(anthropicRouter?.options.baseURL).toContain('/api/anthropic');
+
+        // Check google router
+        const googleRouter = routers.find((r) => r.apiType === 'google');
+        expect(googleRouter).toBeDefined();
+        expect(googleRouter?.options.baseURL).toContain('/api/vertex-ai');
+
+        // Check openai router (default)
+        const openaiRouter = routers.find((r) => r.apiType === 'openai');
+        expect(openaiRouter).toBeDefined();
+        expect(openaiRouter?.options.baseURL).toContain('/api/v1');
+      });
+
+      it('should strip version paths from baseURL', () => {
+        const mockOptions = { baseURL: 'https://zenmux.ai/v1' };
+        const routers = params.routers(mockOptions);
+
+        const anthropicRouter = routers.find((r) => r.apiType === 'anthropic');
+        expect(anthropicRouter?.options.baseURL).toBe('https://zenmux.ai/api/anthropic');
+      });
+
+      it('should use default baseURL when not provided', () => {
+        const mockOptions = {}; // No baseURL provided
+        const routers = params.routers(mockOptions);
+
+        const anthropicRouter = routers.find((r) => r.apiType === 'anthropic');
+        expect(anthropicRouter?.options.baseURL).toBe('https://zenmux.ai/api/anthropic');
+
+        const googleRouter = routers.find((r) => r.apiType === 'google');
+        expect(googleRouter?.options.baseURL).toBe('https://zenmux.ai/api/vertex-ai');
+
+        const openaiRouter = routers.find((r) => r.apiType === 'openai');
+        expect(openaiRouter?.options.baseURL).toBe('https://zenmux.ai/api/v1');
+      });
+    });
+    describe('Models Function', () => {
+      it('should fetch and process models correctly', async () => {
+        const mockClient = {
+          apiKey: 'test-key',
+          baseURL: 'https://zenmux.ai/api/v1',
+          models: {
+            list: vi.fn().mockResolvedValue({
+              data: [
+                {
+                  id: 'openai/gpt-4o-mini',
+                  object: 'model',
+                  created: 1755177025,
+                  owned_by: 'openai',
+                },
+                {
+                  id: 'anthropic/claude-3-5-sonnet-20241022',
+                  object: 'model',
+                  created: 1755177025,
+                  owned_by: 'anthropic',
+                },
+              ],
+            }),
+          },
+        } as any;
+
+        // Mock processMultiProviderModelList to return processed models
+        mockProcessMultiProviderModelList.mockResolvedValue([
+          {
+            id: 'openai/gpt-4o-mini',
+            displayName: 'GPT-4o Mini',
+            providerId: 'openai',
+          },
+          {
+            id: 'anthropic/claude-3-5-sonnet-20241022',
+            displayName: 'Claude 3.5 Sonnet',
+            providerId: 'anthropic',
+          },
+        ] as any);
+
+        const models = await params.models({ client: mockClient });
+
+        expect(models).toBeDefined();
+        expect(Array.isArray(models)).toBe(true);
+        expect(models.length).toBeGreaterThan(0);
+      });
+
+      it('should handle empty model list', async () => {
+        const mockClient = {
+          apiKey: 'test-key',
+          baseURL: 'https://zenmux.ai/api/v1',
+          models: {
+            list: vi.fn().mockResolvedValue({
+              data: [],
+            }),
+          },
+        } as any;
+
+        // Mock processMultiProviderModelList
+        mockProcessMultiProviderModelList.mockResolvedValue([]);
+
+        const models = await params.models({ client: mockClient });
+
+        expect(models).toBeDefined();
+        expect(Array.isArray(models)).toBe(true);
+        expect(models.length).toBe(0);
+      });
+    });
+  });
+});

package/packages/model-runtime/src/providers/zenmux/index.ts

@@ -0,0 +1,84 @@
+import { LOBE_DEFAULT_MODEL_LIST, ModelProvider } from 'model-bank';
+import urlJoin from 'url-join';
+
+import { createRouterRuntime } from '../../core/RouterRuntime';
+import { CreateRouterRuntimeOptions } from '../../core/RouterRuntime/createRuntime';
+import { detectModelProvider, processMultiProviderModelList } from '../../utils/modelParse';
+
+export interface ZenMuxModelCard {
+  created: number;
+  id: string;
+  object: string;
+  owned_by: string;
+}
+
+const DEFAULT_BASE_URL = 'https://zenmux.ai';
+
+export const params = {
+  chatCompletion: {
+    handlePayload: (payload) => {
+      const { reasoning_effort, thinking, reasoning, ...rest } = payload;
+
+      const finalReasoning = {
+        ...reasoning,
+        ...(reasoning_effort && { effort: reasoning_effort }),
+        ...(thinking?.budget_tokens && { max_tokens: thinking.budget_tokens }),
+        ...(thinking?.type === 'enabled' && { enabled: true }),
+        ...(thinking?.type === 'disabled' && { enabled: false }),
+      };
+
+      const hasReasoning = Object.keys(finalReasoning).length > 0;
+
+      return {
+        ...rest,
+        ...(hasReasoning && { reasoning: finalReasoning }),
+      } as any;
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_ZENMUX_CHAT_COMPLETION === '1',
+  },
+  id: ModelProvider.ZenMux,
+  models: async ({ client: openAIClient }) => {
+    const modelsPage = (await openAIClient.models.list()) as any;
+    const modelList: ZenMuxModelCard[] = modelsPage.data || [];
+
+    return processMultiProviderModelList(modelList, 'zenmux');
+  },
+  routers: (options) => {
+    const baseURL = options.baseURL || DEFAULT_BASE_URL;
+    const userBaseURL = baseURL.replace(/\/v\d+[a-z]*\/?$/, '').replace(/\/api\/?$/, '');
+
+    return [
+      {
+        apiType: 'anthropic',
+        models: LOBE_DEFAULT_MODEL_LIST.map((m) => m.id).filter(
+          (id) => detectModelProvider(id) === 'anthropic',
+        ),
+        options: {
+          ...options,
+          baseURL: urlJoin(userBaseURL, '/api/anthropic'),
+        },
+      },
+      {
+        apiType: 'google',
+        models: LOBE_DEFAULT_MODEL_LIST.map((m) => m.id).filter(
+          (id) => detectModelProvider(id) === 'google',
+        ),
+        options: {
+          ...options,
+          baseURL: urlJoin(userBaseURL, '/api/vertex-ai'),
+        },
+      },
+      {
+        apiType: 'openai',
+        options: {
+          ...options,
+          baseURL: urlJoin(userBaseURL, '/api/v1'),
+        },
+      },
+    ];
+  },
+} satisfies CreateRouterRuntimeOptions;
+
+export const LobeZenMuxAI = createRouterRuntime(params);

package/packages/model-runtime/src/runtimeMap.ts

@@ -61,6 +61,7 @@ import { LobeVolcengineAI } from './providers/volcengine';
 import { LobeWenxinAI } from './providers/wenxin';
 import { LobeXAI } from './providers/xai';
 import { LobeXinferenceAI } from './providers/xinference';
+import { LobeZenMuxAI } from './providers/zenmux';
 import { LobeZeroOneAI } from './providers/zeroone';
 import { LobeZhipuAI } from './providers/zhipu';
 
@@ -128,6 +129,7 @@ export const providerRuntimeMap = {
   wenxin: LobeWenxinAI,
   xai: LobeXAI,
   xinference: LobeXinferenceAI,
+  zenmux: LobeZenMuxAI,
   zeroone: LobeZeroOneAI,
   zhipu: LobeZhipuAI,
 };

package/packages/types/src/user/settings/keyVaults.ts

@@ -117,6 +117,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   wenxin?: OpenAICompatibleKeyVault;
   xai?: OpenAICompatibleKeyVault;
   xinference?: OpenAICompatibleKeyVault;
+  zenmux?: OpenAICompatibleKeyVault;
   zeroone?: OpenAICompatibleKeyVault;
   zhipu?: OpenAICompatibleKeyVault;
 }

package/src/app/[variants]/(main)/image/@menu/features/ConfigPanel/components/ModelSelect/ImageModelItem.tsx

@@ -7,6 +7,8 @@ import numeral from 'numeral';
 import { memo, useMemo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
+import NewModelBadge from '@/components/ModelSelect/NewModelBadge';
+
 const POPOVER_MAX_WIDTH = 320;
 
 const useStyles = createStyles(({ css, token, isDarkMode }) => ({
@@ -25,6 +27,11 @@ const useStyles = createStyles(({ css, token, isDarkMode }) => ({
 }));
 
 type ImageModelItemProps = AiModelForSelect & {
+  /**
+   * Whether to show new model badge
+   * @default true
+   */
+  showBadge?: boolean;
   /**
    * Whether to show popover on hover
    * @default true
@@ -33,7 +40,14 @@ type ImageModelItemProps = AiModelForSelect & {
 };
 
 const ImageModelItem = memo<ImageModelItemProps>(
-  ({ approximatePricePerImage, description, pricePerImage, showPopover = true, ...model }) => {
+  ({
+    approximatePricePerImage,
+    description,
+    pricePerImage,
+    showPopover = true,
+    showBadge = true,
+    ...model
+  }) => {
     const { styles } = useStyles();
 
     const priceLabel = useMemo(() => {
@@ -67,6 +81,7 @@ const ImageModelItem = memo<ImageModelItemProps>(
         <Text ellipsis title={model.displayName || model.id}>
           {model.displayName || model.id}
         </Text>
+        {showBadge && <NewModelBadge releasedAt={model.releasedAt} />}
       </Flexbox>
     );
 

package/src/app/[variants]/(main)/image/@menu/features/ConfigPanel/components/ModelSelect/index.tsx

@@ -2,7 +2,6 @@ import { EnabledProviderWithModels } from '@lobechat/types';
 import { ActionIcon, Icon, Select, type SelectProps } from '@lobehub/ui';
 import { createStyles, useTheme } from 'antd-style';
 import { LucideArrowRight, LucideBolt } from 'lucide-react';
-import Link from 'next/link';
 import { memo, useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
@@ -107,13 +106,15 @@ const ModelSelect = memo(() => {
             provider={provider.id}
             source={provider.source}
           />
-          <Link href={`/settings?active=provider&provider=${provider.id}`}>
-            <ActionIcon
-              icon={LucideBolt}
-              size={'small'}
-              title={t('ModelSwitchPanel.goToSettings')}
-            />
-          </Link>
+          <ActionIcon
+            icon={LucideBolt}
+            onClick={(e) => {
+              e.stopPropagation();
+              navigate(`/settings?active=provider&provider=${provider.id}`);
+            }}
+            size={'small'}
+            title={t('ModelSwitchPanel.goToSettings')}
+          />
         </Flexbox>
       ),
       options: getImageModels(provider),
@@ -129,7 +130,7 @@ const ModelSelect = memo(() => {
 
     if (!modelInfo) return props.label;
 
-    return <ImageModelItem {...modelInfo} showPopover={false} />;
+    return <ImageModelItem {...modelInfo} showBadge={false} showPopover={false} />;
   };
 
   return (

package/src/app/[variants]/(main)/image/@menu/features/ConfigPanel/components/ResolutionSelect.tsx

@@ -0,0 +1,88 @@
+import { createStyles } from 'antd-style';
+import { memo, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Flexbox } from 'react-layout-kit';
+
+import { useGenerationConfigParam } from '@/store/image/slices/generationConfig/hooks';
+
+const useStyles = createStyles(({ css, token }) => ({
+  button: css`
+    cursor: pointer;
+
+    display: flex;
+    align-items: center;
+    justify-content: center;
+
+    min-width: 60px;
+    height: 32px;
+    padding-block: 0;
+    padding-inline: 16px;
+    border: 1px solid ${token.colorBorder};
+    border-radius: ${token.borderRadius}px;
+
+    font-size: 14px;
+    font-weight: 500;
+    color: ${token.colorText};
+
+    background: ${token.colorBgContainer};
+
+    transition: all 0.2s ease;
+
+    &:hover {
+      border-color: ${token.colorPrimary};
+      background: ${token.colorBgTextHover};
+    }
+  `,
+
+  container: css`
+    display: flex;
+    gap: 8px;
+    align-items: center;
+  `,
+
+  selectedButton: css`
+    border-color: ${token.colorPrimary};
+    color: ${token.colorPrimary};
+    background: ${token.colorPrimaryBg};
+
+    &:hover {
+      border-color: ${token.colorPrimary};
+      color: ${token.colorPrimary};
+      background: ${token.colorPrimaryBgHover};
+    }
+  `,
+}));
+
+const ResolutionSelect = memo(() => {
+  const { t } = useTranslation('image');
+  const { value, setValue, enumValues } = useGenerationConfigParam('resolution');
+  const { styles, cx } = useStyles();
+
+  const handleClick = useCallback(
+    (resolution: string) => {
+      setValue(resolution);
+    },
+    [setValue],
+  );
+
+  if (!enumValues || enumValues.length === 0) {
+    return null;
+  }
+
+  return (
+    <Flexbox className={styles.container} horizontal>
+      {enumValues.map((resolution) => (
+        <button
+          className={cx(styles.button, value === resolution && styles.selectedButton)}
+          key={resolution}
+          onClick={() => handleClick(resolution)}
+          type="button"
+        >
+          {t(`config.resolution.options.${resolution}`, { defaultValue: resolution })}
+        </button>
+      ))}
+    </Flexbox>
+  );
+});
+
+export default ResolutionSelect;