@lobehub/lobehub 2.0.0-next.47 → 2.0.0-next.48

package/src/services/chat/chat.test.ts

@@ -27,7 +27,7 @@ vi.stubGlobal(
 );
 
 // Mock image processing utilities
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };
@@ -988,7 +988,7 @@ describe('ChatService', () => {
 
     beforeEach(async () => {
       // Setup common fetchSSE mock for getChatCompletion tests
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
       mockFetchSSE = vi.fn().mockResolvedValue(new Response('mock response'));
       vi.mocked(fetchSSE).mockImplementation(mockFetchSSE);
     });
@@ -1049,7 +1049,7 @@ describe('ChatService', () => {
 
     it('should return InvalidAccessCode error when enableFetchOnClient is true and auth is enabled but user is not signed in', async () => {
       // Mock fetchSSE to call onErrorHandle with the error
-      const { fetchSSE } = await import('@/utils/fetch');
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
 
       const mockFetchSSEWithError = vi.fn().mockImplementation((url, options) => {
         // Simulate the error being caught and passed to onErrorHandle
@@ -1211,8 +1211,8 @@ vi.mock('../_auth', async (importOriginal) => {
 describe('ChatService private methods', () => {
   describe('getChatCompletion', () => {
     it('should merge responseAnimation styles correctly', async () => {
-      const { fetchSSE } = await import('@/utils/fetch');
-      vi.mock('@/utils/fetch', async (importOriginal) => {
+      const { fetchSSE } = await import('@lobechat/fetch-sse');
+      vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
         const module = await importOriginal();
         return {
           ...(module as any),

package/src/services/chat/clientModelRuntime.test.ts

@@ -38,7 +38,7 @@ vi.stubGlobal(
   vi.fn(() => Promise.resolve(new Response(JSON.stringify({ some: 'data' })))),
 );
 
-vi.mock('@/utils/fetch', async (importOriginal) => {
+vi.mock('@lobechat/fetch-sse', async (importOriginal) => {
   const module = await importOriginal();
 
   return { ...(module as any), getMessageError: vi.fn() };

package/src/services/chat/index.ts

@@ -1,3 +1,9 @@
+import {
+  FetchSSEOptions,
+  fetchSSE,
+  getMessageError,
+  standardizeAnimationStyle,
+} from '@lobechat/fetch-sse';
 import { AgentRuntimeError, ChatCompletionErrorPayload } from '@lobechat/model-runtime';
 import { ChatErrorType, TracePayload, TraceTagMap, UIChatMessage } from '@lobechat/types';
 import { PluginRequestPayload, createHeadersWithPluginSettings } from '@lobehub/chat-plugin-sdk';
@@ -25,12 +31,6 @@ import {
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
 import { fetchWithInvokeStream } from '@/utils/electron/desktopRemoteRPCFetch';
 import { createErrorResponse } from '@/utils/errorResponse';
-import {
-  FetchSSEOptions,
-  fetchSSE,
-  getMessageError,
-  standardizeAnimationStyle,
-} from '@/utils/fetch';
 import { createTraceHeader, getTraceId } from '@/utils/trace';
 
 import { createHeaderWithAuth } from '../_auth';

package/src/services/chat/types.ts

@@ -1,7 +1,6 @@
+import { FetchSSEOptions } from '@lobechat/fetch-sse';
 import { TracePayload } from '@lobechat/types';
 
-import { FetchSSEOptions } from '@/utils/fetch';
-
 export interface FetchOptions extends FetchSSEOptions {
   historySummary?: string;
   signal?: AbortSignal | undefined;

package/src/services/discover.ts

@@ -7,6 +7,7 @@ import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
 import {
   AssistantListResponse,
+  AssistantMarketSource,
   AssistantQueryParams,
   DiscoverAssistantDetail,
   DiscoverMcpDetail,
@@ -30,27 +31,37 @@ class DiscoverService {
   private _isRetrying = false;
 
   // ============================== Assistant Market ==============================
-  getAssistantCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+  getAssistantCategories = async (
+    params: CategoryListQuery & { source?: AssistantMarketSource } = {},
+  ): Promise<CategoryItem[]> => {
     const locale = globalHelpers.getCurrentLanguage();
+    const { source, ...rest } = params;
     return lambdaClient.market.getAssistantCategories.query({
-      ...params,
+      ...rest,
       locale,
+      source,
     });
   };
 
   getAssistantDetail = async (params: {
     identifier: string;
     locale?: string;
+    source?: AssistantMarketSource;
+    version?: string;
   }): Promise<DiscoverAssistantDetail | undefined> => {
     const locale = globalHelpers.getCurrentLanguage();
     return lambdaClient.market.getAssistantDetail.query({
-      ...params,
+      identifier: params.identifier,
       locale,
+      source: params.source,
+      version: params.version,
     });
   };
 
-  getAssistantIdentifiers = async (): Promise<IdentifiersResponse> => {
-    return lambdaClient.market.getAssistantIdentifiers.query();
+  getAssistantIdentifiers = async (
+    params: { source?: AssistantMarketSource } = {},
+  ): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getAssistantIdentifiers.query(params);
   };
 
   getAssistantList = async (params: AssistantQueryParams = {}): Promise<AssistantListResponse> => {

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,4 @@
-import { DataSyncConfig, dispatch } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, MarketAuthorizationParams, dispatch } from '@lobechat/electron-client-ipc';
 
 class RemoteServerService {
   /**
@@ -28,6 +28,13 @@ class RemoteServerService {
   requestAuthorization = async (config: DataSyncConfig) => {
     return dispatch('requestAuthorization', config);
   };
+
+  /**
+   * 请求 Market 授权
+   */
+  requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
+    return dispatch('requestMarketAuthorization', params);
+  };
 }
 
 export const remoteServerService = new RemoteServerService();

package/src/services/marketApi.ts

@@ -0,0 +1,124 @@
+import { AgentItemDetail } from '@lobehub/market-sdk';
+
+import { MARKET_ENDPOINTS } from '@/services/_url';
+
+export class MarketApiService {
+  private accessToken?: string;
+
+  // eslint-disable-next-line no-undef
+  private async request<T>(endpoint: string, init?: RequestInit): Promise<T> {
+    const headers = new Headers(init?.headers);
+
+    if (init?.body && !headers.has('content-type')) {
+      headers.set('content-type', 'application/json');
+    }
+
+    if (this.accessToken && !headers.has('authorization')) {
+      headers.set('authorization', `Bearer ${this.accessToken}`);
+    }
+
+    const response = await fetch(endpoint, {
+      ...init,
+      credentials: init?.credentials ?? 'same-origin',
+      headers,
+    });
+
+    if (!response.ok) {
+      let message = 'Unknown error';
+
+      try {
+        const errorBody = await response.json();
+        message = errorBody?.message ?? message;
+      } catch {
+        message = await response.text();
+      }
+
+      throw new Error(message || 'Market request failed');
+    }
+
+    if (response.status === 204) {
+      return undefined as T;
+    }
+
+    return (await response.json()) as T;
+  }
+
+  setAccessToken(token: string) {
+    this.accessToken = token;
+  }
+  // Create new agent
+  async createAgent(agentData: {
+    homepage?: string;
+    identifier: string;
+    isFeatured?: boolean;
+    name: string;
+    status?: 'published' | 'unpublished' | 'archived' | 'deprecated';
+    tokenUsage?: number;
+    visibility?: 'public' | 'private' | 'internal';
+  }): Promise<AgentItemDetail> {
+    return this.request(MARKET_ENDPOINTS.createAgent, {
+      body: JSON.stringify(agentData),
+      method: 'POST',
+    });
+  }
+
+  // Get agent detail by identifier
+  async getAgentDetail(identifier: string): Promise<AgentItemDetail> {
+    return this.request(MARKET_ENDPOINTS.getAgentDetail(identifier), {
+      method: 'GET',
+    });
+  }
+
+  // Check if agent exists (returns true if exists, false if not)
+  async checkAgentExists(identifier: string): Promise<boolean> {
+    try {
+      await this.getAgentDetail(identifier);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Create agent version
+  async createAgentVersion(versionData: {
+    a2aProtocolVersion?: string;
+    avatar?: string;
+    category?: string;
+    changelog?: string;
+    config?: Record<string, any>;
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    description?: string;
+    documentationUrl?: string;
+    extensions?: Record<string, any>[];
+    hasPushNotifications?: boolean;
+    hasStateTransitionHistory?: boolean;
+    hasStreaming?: boolean;
+    identifier: string;
+    interfaces?: Record<string, any>[];
+    name?: string;
+    preferredTransport?: string;
+    providerId?: number;
+    securityRequirements?: Record<string, any>[];
+    securitySchemes?: Record<string, any>;
+    setAsCurrent?: boolean;
+    summary?: string;
+    supportsAuthenticatedExtendedCard?: boolean;
+    tokenUsage?: number;
+    url?: string;
+  }): Promise<AgentItemDetail> {
+    const { identifier, ...rest } = versionData;
+    const targetIdentifier = identifier;
+    if (!targetIdentifier) throw new Error('Identifier is required');
+
+    return this.request(MARKET_ENDPOINTS.createAgentVersion, {
+      body: JSON.stringify({
+        identifier: targetIdentifier,
+        ...rest,
+      }),
+      method: 'POST',
+    });
+  }
+}
+
+export const marketApiService = new MarketApiService();

package/src/services/models.ts

@@ -1,7 +1,8 @@
+import { getMessageError } from '@lobechat/fetch-sse';
+
 import { createHeaderWithAuth } from '@/services/_auth';
 import { aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
 import { ChatModelCard } from '@/types/llm';
-import { getMessageError } from '@/utils/fetch';
 
 import { API_ENDPOINTS } from './_url';
 import { initializeWithClientStore } from './chat/clientModelRuntime';

package/src/store/discover/slices/assistant/action.ts

@@ -7,17 +7,24 @@ import { DiscoverStore } from '@/store/discover';
 import { globalHelpers } from '@/store/global/helpers';
 import {
   AssistantListResponse,
+  AssistantMarketSource,
   AssistantQueryParams,
   DiscoverAssistantDetail,
   IdentifiersResponse,
 } from '@/types/discover';
 
 export interface AssistantAction {
-  useAssistantCategories: (params: CategoryListQuery) => SWRResponse<CategoryItem[]>;
+  useAssistantCategories: (
+    params: CategoryListQuery & { source?: AssistantMarketSource },
+  ) => SWRResponse<CategoryItem[]>;
   useAssistantDetail: (params: {
     identifier: string;
+    source?: AssistantMarketSource;
+    version?: string;
   }) => SWRResponse<DiscoverAssistantDetail | undefined>;
-  useAssistantIdentifiers: () => SWRResponse<IdentifiersResponse>;
+  useAssistantIdentifiers: (params?: {
+    source?: AssistantMarketSource;
+  }) => SWRResponse<IdentifiersResponse>;
   useAssistantList: (params?: AssistantQueryParams) => SWRResponse<AssistantListResponse>;
 }
 
@@ -41,7 +48,9 @@ export const createAssistantSlice: StateCreator<
   useAssistantDetail: (params) => {
     const locale = globalHelpers.getCurrentLanguage();
     return useSWR(
-      ['assistant-details', locale, params.identifier].filter(Boolean).join('-'),
+      ['assistant-details', locale, params.identifier, params.version, params.source]
+        .filter(Boolean)
+        .join('-'),
       async () => discoverService.getAssistantDetail(params),
       {
         revalidateOnFocus: false,
@@ -49,10 +58,14 @@ export const createAssistantSlice: StateCreator<
     );
   },
 
-  useAssistantIdentifiers: () => {
-    return useSWR('assistant-identifiers', async () => discoverService.getAssistantIdentifiers(), {
-      revalidateOnFocus: false,
-    });
+  useAssistantIdentifiers: (params) => {
+    return useSWR(
+      ['assistant-identifiers', params?.source].filter(Boolean).join('-') || 'assistant-identifiers',
+      async () => discoverService.getAssistantIdentifiers(params),
+      {
+        revalidateOnFocus: false,
+      },
+    );
   },
 
   useAssistantList: (params = {}) => {

package/{packages/utils/src → src/utils}/electron/desktopRemoteRPCFetch.ts

@@ -1,10 +1,10 @@
 import { isDesktop } from '@lobechat/const';
 import { ProxyTRPCRequestParams, dispatch, streamInvoke } from '@lobechat/electron-client-ipc';
+import { getRequestBody, headersToRecord } from '@lobechat/fetch-sse';
 import debug from 'debug';
 
 import { getElectronStoreState } from '@/store/electron';
 import { electronSyncSelectors } from '@/store/electron/selectors';
-import { getRequestBody, headersToRecord } from '@/utils/fetch';
 
 const log = debug('utils:desktopRemoteRPCFetch');
 

package/{packages/utils/src → src/utils/server}/parseModels.ts

@@ -1,9 +1,8 @@
 import { getModelPropertyWithFallback } from '@lobechat/model-runtime';
+import { merge } from '@lobechat/utils';
 import { produce } from 'immer';
 import { AiFullModelCard, AiModelType } from 'model-bank';
 
-import { merge } from './merge';
-
 /**
  * Parse model string to add or remove models.
  */

package/vitest.config.mts

@@ -16,6 +16,8 @@ export default defineConfig({
       // TODO: after refactor the errorResponse, we can remove it
       '@/utils/errorResponse': resolve(__dirname, './src/utils/errorResponse'),
       '@/utils/unzipFile': resolve(__dirname, './src/utils/unzipFile'),
+      '@/utils/server': resolve(__dirname, './src/utils/server'),
+      '@/utils/electron': resolve(__dirname, './src/utils/electron'),
       '@/utils': resolve(__dirname, './packages/utils/src'),
       '@/types': resolve(__dirname, './packages/types/src'),
       '@/const': resolve(__dirname, './packages/const/src'),

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

@@ -1,91 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { imageToBase64, imageUrlToBase64 } from './imageToBase64';
-
-describe('imageToBase64', () => {
-  let mockImage: HTMLImageElement;
-  let mockCanvas: HTMLCanvasElement;
-  let mockContext: CanvasRenderingContext2D;
-
-  beforeEach(() => {
-    mockImage = {
-      width: 200,
-      height: 100,
-    } as HTMLImageElement;
-
-    mockContext = {
-      drawImage: vi.fn(),
-    } as unknown as CanvasRenderingContext2D;
-
-    mockCanvas = {
-      width: 0,
-      height: 0,
-      getContext: vi.fn().mockReturnValue(mockContext),
-      toDataURL: vi.fn().mockReturnValue('data:image/webp;base64,mockBase64Data'),
-    } as unknown as HTMLCanvasElement;
-
-    vi.spyOn(document, 'createElement').mockReturnValue(mockCanvas);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should convert image to base64 with correct size and type', () => {
-    const result = imageToBase64({ img: mockImage, size: 100, type: 'image/jpeg' });
-
-    expect(document.createElement).toHaveBeenCalledWith('canvas');
-    expect(mockCanvas.width).toBe(100);
-    expect(mockCanvas.height).toBe(100);
-    expect(mockCanvas.getContext).toHaveBeenCalledWith('2d');
-    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 50, 0, 100, 100, 0, 0, 100, 100);
-    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/jpeg');
-    expect(result).toBe('data:image/webp;base64,mockBase64Data');
-  });
-
-  it('should use default type when not specified', () => {
-    imageToBase64({ img: mockImage, size: 100 });
-    expect(mockCanvas.toDataURL).toHaveBeenCalledWith('image/webp');
-  });
-
-  it('should handle taller images correctly', () => {
-    mockImage.width = 100;
-    mockImage.height = 200;
-    imageToBase64({ img: mockImage, size: 100 });
-    expect(mockContext.drawImage).toHaveBeenCalledWith(mockImage, 0, 50, 100, 100, 0, 0, 100, 100);
-  });
-});
-
-describe('imageUrlToBase64', () => {
-  const mockFetch = vi.fn();
-  const mockArrayBuffer = new ArrayBuffer(8);
-
-  beforeEach(() => {
-    global.fetch = mockFetch;
-    global.btoa = vi.fn().mockReturnValue('mockBase64String');
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should convert image URL to base64 string', async () => {
-    mockFetch.mockResolvedValue({
-      arrayBuffer: () => Promise.resolve(mockArrayBuffer),
-      blob: () => Promise.resolve(new Blob([mockArrayBuffer], { type: 'image/jpg' })),
-    });
-
-    const result = await imageUrlToBase64('https://example.com/image.jpg');
-
-    expect(mockFetch).toHaveBeenCalledWith('https://example.com/image.jpg');
-    expect(global.btoa).toHaveBeenCalled();
-    expect(result).toEqual({ base64: 'mockBase64String', mimeType: 'image/jpg' });
-  });
-
-  it('should throw an error when fetch fails', async () => {
-    const mockError = new Error('Fetch failed');
-    mockFetch.mockRejectedValue(mockError);
-
-    await expect(imageUrlToBase64('https://example.com/image.jpg')).rejects.toThrow('Fetch failed');
-  });
-});

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

@@ -1,62 +0,0 @@
-export const imageToBase64 = ({
-  size,
-  img,
-  type = 'image/webp',
-}: {
-  img: HTMLImageElement;
-  size: number;
-  type?: string;
-}) => {
-  const canvas = document.createElement('canvas');
-  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D;
-  let startX = 0;
-  let startY = 0;
-
-  if (img.width > img.height) {
-    startX = (img.width - img.height) / 2;
-  } else {
-    startY = (img.height - img.width) / 2;
-  }
-
-  canvas.width = size;
-  canvas.height = size;
-
-  ctx.drawImage(
-    img,
-    startX,
-    startY,
-    Math.min(img.width, img.height),
-    Math.min(img.width, img.height),
-    0,
-    0,
-    size,
-    size,
-  );
-
-  return canvas.toDataURL(type);
-};
-
-export const imageUrlToBase64 = async (
-  imageUrl: string,
-): Promise<{ base64: string; mimeType: string }> => {
-  try {
-    const res = await fetch(imageUrl);
-    const blob = await res.blob();
-    const arrayBuffer = await blob.arrayBuffer();
-
-    const base64 =
-      typeof btoa === 'function'
-        ? btoa(
-            new Uint8Array(arrayBuffer).reduce(
-              (data, byte) => data + String.fromCharCode(byte),
-              '',
-            ),
-          )
-        : Buffer.from(arrayBuffer).toString('base64');
-
-    return { base64, mimeType: blob.type };
-  } catch (error) {
-    console.error('Error converting image to base64:', error);
-    throw error;
-  }
-};

package/src/app/[variants]/(main)/chat/settings/features/SubmitAgentButton/SubmitAgentModal.tsx

@@ -1,98 +0,0 @@
-'use client';
-
-import { Alert, Button, Input, Modal, type ModalProps } from '@lobehub/ui';
-import { Divider } from 'antd';
-import { useTheme } from 'antd-style';
-import isEqual from 'fast-deep-equal';
-import { kebabCase } from 'lodash-es';
-import qs from 'query-string';
-import { memo, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Flexbox } from 'react-layout-kit';
-
-import { AGENTS_INDEX_GITHUB_ISSUE } from '@/const/url';
-import AgentInfo from '@/features/AgentInfo';
-import { useAgentStore } from '@/store/agent';
-import { agentSelectors } from '@/store/agent/selectors';
-import { useGlobalStore } from '@/store/global';
-import { globalGeneralSelectors } from '@/store/global/selectors';
-import { useSessionStore } from '@/store/session';
-import { sessionMetaSelectors } from '@/store/session/selectors';
-
-const SubmitAgentModal = memo<ModalProps>(({ open, onCancel }) => {
-  const { t } = useTranslation('setting');
-  const [identifier, setIdentifier] = useState('');
-  const systemRole = useAgentStore(agentSelectors.currentAgentSystemRole);
-  const theme = useTheme();
-  const meta = useSessionStore(sessionMetaSelectors.currentAgentMeta, isEqual);
-  const language = useGlobalStore(globalGeneralSelectors.currentLanguage);
-
-  const isMetaPass = Boolean(
-    meta && meta.title && meta.description && (meta.tags as string[])?.length > 0 && meta.avatar,
-  );
-
-  const handleSubmit = () => {
-    const body = [
-      '### systemRole',
-      systemRole,
-      '### identifier',
-      kebabCase(identifier),
-      '### avatar',
-      meta.avatar,
-      '### title',
-      meta.title,
-      '### description',
-      meta.description,
-      '### tags',
-      (meta.tags as string[]).join(', '),
-      '### locale',
-      language,
-    ].join('\n\n');
-
-    const url = qs.stringifyUrl({
-      query: { body, labels: '🤖 Agent PR', title: `[Agent] ${meta.title}` },
-      url: AGENTS_INDEX_GITHUB_ISSUE,
-    });
-
-    window.open(url, '_blank');
-  };
-
-  return (
-    <Modal
-      allowFullscreen
-      footer={
-        <Button
-          block
-          disabled={!isMetaPass || !identifier}
-          onClick={handleSubmit}
-          size={'large'}
-          type={'primary'}
-        >
-          {t('submitAgentModal.button')}
-        </Button>
-      }
-      onCancel={onCancel}
-      open={open}
-      title={t('submitAgentModal.tooltips')}
-    >
-      <Flexbox gap={16}>
-        {!isMetaPass && (
-          <Alert message={t('submitAgentModal.metaMiss')} showIcon type={'warning'} />
-        )}
-        <AgentInfo meta={meta} systemRole={systemRole} />
-        <Divider style={{ margin: '8px 0' }} />
-        <strong>
-          <span style={{ color: theme.colorError, marginRight: 4 }}>*</span>
-          {t('submitAgentModal.identifier')}
-        </strong>
-        <Input
-          onChange={(e) => setIdentifier(e.target.value)}
-          placeholder={t('submitAgentModal.placeholder')}
-          value={identifier}
-        />
-      </Flexbox>
-    </Modal>
-  );
-});
-
-export default SubmitAgentModal;

package/src/app/[variants]/(main)/chat/settings/features/SubmitAgentButton/index.tsx

@@ -1,35 +0,0 @@
-import { ActionIcon, Button } from '@lobehub/ui';
-import { Share2 } from 'lucide-react';
-import { memo, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-
-import { HEADER_ICON_SIZE } from '@/const/layoutTokens';
-import { useServerConfigStore } from '@/store/serverConfig';
-
-import SubmitAgentModal from './SubmitAgentModal';
-
-const SubmitAgentButton = memo<{ modal?: boolean }>(({ modal }) => {
-  const { t } = useTranslation('setting');
-  const mobile = useServerConfigStore((s) => s.isMobile);
-  const [isModalOpen, setIsModalOpen] = useState(false);
-
-  return (
-    <>
-      {modal ? (
-        <Button block icon={Share2} onClick={() => setIsModalOpen(true)} variant={'filled'}>
-          {t('submitAgentModal.tooltips')}
-        </Button>
-      ) : (
-        <ActionIcon
-          icon={Share2}
-          onClick={() => setIsModalOpen(true)}
-          size={HEADER_ICON_SIZE(mobile)}
-          title={t('submitAgentModal.tooltips')}
-        />
-      )}
-      <SubmitAgentModal onCancel={() => setIsModalOpen(false)} open={isModalOpen} />
-    </>
-  );
-});
-
-export default SubmitAgentButton;