@lobehub/lobehub 2.0.0-next.100 → 2.0.0-next.102

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/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;

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

@@ -19,6 +19,7 @@ import ImageUrl from './components/ImageUrl';
 import ImageUrlsUpload from './components/ImageUrlsUpload';
 import ModelSelect from './components/ModelSelect';
 import QualitySelect from './components/QualitySelect';
+import ResolutionSelect from './components/ResolutionSelect';
 import SeedNumberInput from './components/SeedNumberInput';
 import SizeSelect from './components/SizeSelect';
 import StepsSliderInput from './components/StepsSliderInput';
@@ -54,6 +55,7 @@ const ConfigPanel = memo(() => {
   const isSupportImageUrl = useImageStore(isSupportedParamSelector('imageUrl'));
   const isSupportSize = useImageStore(isSupportedParamSelector('size'));
   const isSupportQuality = useImageStore(isSupportedParamSelector('quality'));
+  const isSupportResolution = useImageStore(isSupportedParamSelector('resolution'));
   const isSupportSeed = useImageStore(isSupportedParamSelector('seed'));
   const isSupportSteps = useImageStore(isSupportedParamSelector('steps'));
   const isSupportCfg = useImageStore(isSupportedParamSelector('cfg'));
@@ -78,6 +80,7 @@ const ConfigPanel = memo(() => {
     isSupportImageUrl,
     isSupportSize,
     isSupportQuality,
+    isSupportResolution,
     isSupportSeed,
     isSupportSteps,
     isSupportCfg,
@@ -168,6 +171,12 @@ const ConfigPanel = memo(() => {
         </ConfigItemLayout>
       )}
 
+      {isSupportResolution && (
+        <ConfigItemLayout label={t('config.resolution.label')}>
+          <ResolutionSelect />
+        </ConfigItemLayout>
+      )}
+
       {showDimensionControl && <DimensionControlGroup />}
 
       {isSupportSteps && (

package/src/config/modelProviders/index.ts

@@ -64,6 +64,7 @@ import VolcengineProvider from './volcengine';
 import WenxinProvider from './wenxin';
 import XAIProvider from './xai';
 import XinferenceProvider from './xinference';
+import ZenMuxProvider from './zenmux';
 import ZeroOneProvider from './zeroone';
 import ZhiPuProvider from './zhipu';
 
@@ -190,6 +191,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   CometAPIProvider,
   VercelAIGatewayProvider,
   CerebrasProvider,
+  ZenMuxProvider,
 ];
 
 export const filterEnabledModels = (provider: ModelProviderCard) => {
@@ -266,5 +268,6 @@ export { default as VolcengineProviderCard } from './volcengine';
 export { default as WenxinProviderCard } from './wenxin';
 export { default as XAIProviderCard } from './xai';
 export { default as XinferenceProviderCard } from './xinference';
+export { default as ZenMuxProviderCard } from './zenmux';
 export { default as ZeroOneProviderCard } from './zeroone';
 export { default as ZhiPuProviderCard } from './zhipu';

package/src/config/modelProviders/zenmux.ts

@@ -0,0 +1,21 @@
+import { ModelProviderCard } from '@/types/llm';
+
+const ZenMux: ModelProviderCard = {
+  chatModels: [],
+  checkModel: 'openai/gpt-5-nano',
+  description:
+    'ZenMux 是一个统一的 AI 服务聚合平台，支持 OpenAI、Anthropic、Google VertexAI 等多种主流 AI 服务接口。提供灵活的路由能力，让您可以轻松切换和管理不同的 AI 模型。',
+  id: 'zenmux',
+  name: 'ZenMux',
+  settings: {
+    disableBrowserRequest: true, // CORS error
+    proxyUrl: {
+      placeholder: 'https://zenmux.ai',
+    },
+    sdkType: 'router',
+    showModelFetcher: true,
+  },
+  url: 'https://zenmux.ai',
+};
+
+export default ZenMux;

package/src/envs/llm.ts

@@ -209,6 +209,9 @@ export const getLLMConfig = () => {
 
       ENABLED_CEREBRAS: z.boolean(),
       CEREBRAS_API_KEY: z.string().optional(),
+
+      ENABLED_ZENMUX: z.boolean(),
+      ZENMUX_API_KEY: z.string().optional(),
     },
     runtimeEnv: {
       API_KEY_SELECT_MODE: process.env.API_KEY_SELECT_MODE,
@@ -416,6 +419,9 @@ export const getLLMConfig = () => {
 
       ENABLED_CEREBRAS: !!process.env.CEREBRAS_API_KEY,
       CEREBRAS_API_KEY: process.env.CEREBRAS_API_KEY,
+
+      ENABLED_ZENMUX: !!process.env.ZENMUX_API_KEY,
+      ZENMUX_API_KEY: process.env.ZENMUX_API_KEY,
     },
   });
 };

package/src/locales/default/image.ts

@@ -37,6 +37,14 @@ export default {
         standard: '标准',
       },
     },
+    resolution: {
+      label: '分辨率',
+      options: {
+        '1K': '1K',
+        '2K': '2K',
+        '4K': '4K',
+      },
+    },
     seed: {
       label: '种子',
       random: '随机种子',

package/src/store/chat/slices/aiChat/actions/__tests__/conversationLifecycle.test.ts

@@ -2,6 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { aiChatService } from '@/services/aiChat';
+import { getSessionStoreState } from '@/store/session';
 
 import { useChatStore } from '../../../../store';
 import { TEST_CONTENT, TEST_IDS, createMockMessage } from './fixtures';
@@ -30,6 +31,8 @@ beforeEach(() => {
   resetTestEnvironment();
   setupMockSelectors();
   spyOnMessageService();
+  const sessionStore = getSessionStoreState();
+  vi.spyOn(sessionStore, 'triggerSessionUpdate').mockResolvedValue(undefined);
 
   act(() => {
     useChatStore.setState({

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -530,6 +530,17 @@ export const streamingExecutor: StateCreator<
               get().completeOperation(reasoningOperationId);
               reasoningOperationId = undefined;
             }
+            break;
+          }
+
+          case 'stop': {
+            // Complete reasoning operation when receiving stop signal
+            if (!duration && reasoningOperationId) {
+              duration = Date.now() - thinkingStartAt;
+              get().completeOperation(reasoningOperationId);
+              reasoningOperationId = undefined;
+            }
+            break;
           }
         }
       },