Chore/cleanup warnings (#17974)

web/app/(commonLayout)/datasets/(datasetDetailLayout)/[datasetId]/api/page.tsx

 import React from 'react'
 
-type Props = {}
-
-const page = (props: Props) => {
+const page = () => {
   return (
     <div>dataset detail api</div>
   )

web/app/(commonLayout)/datasets/DatasetCard.tsx

       if (onSuccess)
         onSuccess()
     }
-    catch (e: any) {
+    catch {
     }
     setShowConfirmDelete(false)
   }, [dataset.id, notify, onSuccess, t])

web/app/components/app-sidebar/app-info.tsx

       setAppDetail(app)
       mutateApps()
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.editFailed') })
     }
   }, [appDetail, mutateApps, notify, setAppDetail, t])
       onPlanInfoChanged()
       getRedirection(true, newApp, replace)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.newApp.appCreateFailed') })
     }
   }
       a.download = `${appDetail.name}.yml`
       a.click()
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.exportFailed') })
     }
   }
       }
       setSecretEnvList(list)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.exportFailed') })
     }
   }
       })
     }
     setShowConfirmDelete(false)
-  }, [appDetail, mutateApps, notify, onPlanInfoChanged, replace, t])
+  }, [appDetail, mutateApps, notify, onPlanInfoChanged, replace, setAppDetail, t])
 
   const { isCurrentWorkspaceEditor } = useAppContext()
 

web/app/components/app/annotation/add-annotation-modal/index.tsx

     try {
       await onAdd(payload)
     }
-    catch (e) {
+    catch {
     }
     setIsSaving(false)
 

web/app/components/app/annotation/index.tsx

       setList(data as AnnotationItem[])
       setTotal(total)
     }
-    catch (e) {
+    catch {
 
     }
     setIsLoading(false)

web/app/components/app/annotation/view-annotation-modal/index.tsx

       setHitHistoryList(data as HitHistoryItem[])
       setTotal(total)
     }
-    catch (e) {
+    catch {
     }
   }
 

web/app/components/app/configuration/config/agent/agent-tools/setting-built-in-tool.tsx

           setTempSetting(addDefaultValue(setting, formSchemas))
         }
       }
-      catch (e) { }
+      catch { }
       setIsLoading(false)
     })()
   }, [collection?.name, collection?.id, collection?.type])

web/app/components/app/configuration/dataset-config/settings-modal/index.tsx

         retrieval_model_dict: retrievalConfig,
       })
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
     finally {

web/app/components/app/create-app-dialog/app-list/index.tsx

       localStorage.setItem(NEED_REFRESH_APP_LIST_KEY, '1')
       getRedirection(isCurrentWorkspaceEditor, { id: app.app_id!, mode }, push)
     }
-    catch (e) {
+    catch {
       Toast.notify({ type: 'error', message: t('app.newApp.appCreateFailed') })
     }
   }

web/app/components/app/create-app-modal/index.tsx

       localStorage.setItem(NEED_REFRESH_APP_LIST_KEY, '1')
       getRedirection(isCurrentWorkspaceEditor, app, push)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.newApp.appCreateFailed') })
     }
     isCreatingRef.current = false
   onClick: () => void
 }
 function AppTypeCard({ icon, title, description, active, onClick }: AppTypeCardProps) {
-  const { t } = useTranslation()
   return <div
     className={
       cn(`relative box-content h-[84px] w-[191px] cursor-pointer rounded-xl

web/app/components/app/log-annotation/index.tsx

       { value: PageType.log, text: t('appLog.title') },
       { value: PageType.annotation, text: t('appAnnotation.title') },
     ]
-  }, [appDetail])
+  }, [appDetail?.mode, t])
 
   if (!appDetail) {
     return (

web/app/components/app/log/list.tsx

       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       return true
     }
-    catch (err) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       return false
     }
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       return true
     }
-    catch (err) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       return false
     }
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       return true
     }
-    catch (err) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       return false
     }
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       return true
     }
-    catch (err) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       return false
     }

web/app/components/app/switch-app-modal/index.tsx

         removeOriginal ? replace : push,
       )
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.newApp.appCreateFailed') })
     }
   }

web/app/components/base/audio-btn/audio.player.manager.ts

           this.audioPlayers.cacheBuffers = []
           this.audioPlayers.sourceBuffer?.abort()
         }
-        catch (e) {
+        catch {
         }
       }
 

web/app/components/base/audio-btn/audio.ts

         this.receiveAudioData(value)
       }
     }
-    catch (error) {
+    catch {
       this.isLoadData = false
       this.callback && this.callback('error')
     }

web/app/components/base/audio-gallery/AudioPlayer.tsx

       setWaveformData(normalizedWaveform)
       setIsAudioAvailable(true)
     }
-    catch (error) {
+    catch {
       const waveform: number[] = []
       let prevValue = Math.random()
 

web/app/components/base/chat/chat/thought/index.tsx

     try {
       return JSON.parse(value)[index]
     }
-    catch (e) {
+    catch {
     }
   }
   return value
       if (Array.isArray(JSON.parse(thought.tool)))
         return [JSON.parse(thought.tool), true]
     }
-    catch (e) {
+    catch {
     }
     return [[thought.tool], false]
   })()

web/app/components/base/chat/embedded-chatbot/chat-wrapper.tsx

         isPublicAPI: !isInstalledApp,
       },
     )
-  }, [
-    chatList,
-    handleNewConversationCompleted,
-    handleSend,
-    currentConversationId,
-    currentConversationItem,
-    newConversationInputs,
-    isInstalledApp,
-    appId,
-  ])
+  }, [currentConversationId, currentConversationInputs, newConversationInputs, chatList, handleSend, isInstalledApp, appId, handleNewConversationCompleted])
 
   const doRegenerate = useCallback((chatItem: ChatItemInTree) => {
     const question = chatList.find(item => item.id === chatItem.parentMessageId)!

web/app/components/base/chat/embedded-chatbot/inputs-form/content.tsx

     handleNewConversationInputsChange,
   } = useEmbeddedChatbotContext()
   const inputsFormValue = currentConversationId ? currentConversationInputs : newConversationInputs
-  const readonly = !!currentConversationId
 
   const handleFormChange = useCallback((variable: string, value: any) => {
     setCurrentConversationInputs({

web/app/components/base/markdown.tsx

       try {
         return JSON.parse(String(children).replace(/\n$/, ''))
       }
-      catch (error) { }
+      catch { }
     }
     return JSON.parse('{"title":{"text":"ECharts error - Wrong JSON format."}}')
   }, [language, children])

web/app/components/base/svg-gallery/index.tsx

           setImagePreview(svgToDataURL(svgElement as Element))
         })
       }
-      catch (error) {
+      catch {
         if (svgRef.current)
           svgRef.current.innerHTML = '<span style="padding: 1rem;">Error rendering SVG. Wait for the image content to complete.</span>'
       }

web/app/components/base/tag-management/index.tsx

       setName('')
       setPending(false)
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.tag.failed') })
       setPending(false)
     }

web/app/components/base/tag-management/selector.tsx

       setCreating(false)
       onCreate()
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.tag.failed') })
       setCreating(false)
     }
       await bindTag(tagIDs, targetID, type)
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
   }
       await unBindTag(tagID, targetID, type)
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
   }

web/app/components/base/tag-management/tag-item-editor.tsx

       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       setName(name)
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       setName(tag.name)
       const recoverList = tagList.map((tag) => {
       ])
       setPending(false)
     }
-    catch (e: any) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
       setPending(false)
     }

web/app/components/base/voice-input/index.tsx

       onConverted(audioResponse.text)
       onCancel()
     }
-    catch (e) {
+    catch {
       onConverted('')
       onCancel()
     }
       if (canvasRef.current && ctxRef.current)
         drawRecord()
     }
-    catch (e) {
+    catch {
       onCancel()
     }
   }

web/app/components/browser-initor.tsx

   localStorage = globalThis.localStorage
   sessionStorage = globalThis.sessionStorage
 }
-catch (e) {
+catch {
   localStorage = new StorageMock()
   sessionStorage = new StorageMock()
 }

web/app/components/datasets/api/index.tsx

 import React from 'react'
 
-type Props = {}
-
-const index = (props: Props) => {
+const index = () => {
   return (
     <div>index</div>
   )

web/app/components/datasets/create/embedding-process/index.tsx

       await sleep(2500)
       await startQueryStatus()
     }
-    catch (e) {
+    catch {
       await sleep(2500)
       await startQueryStatus()
     }

web/app/components/datasets/create/empty-dataset-creation-modal/index.tsx

       onHide()
       router.push(`/datasets/${dataset.id}/documents`)
     }
-    catch (err) {
+    catch {
       notify({ type: 'error', message: t('datasetCreation.stepOne.modal.failed') })
     }
   }

web/app/components/datasets/create/website/jina-reader/index.tsx

         },
       }
     }
-  }, [crawlOptions.limit])
+  }, [crawlOptions.limit, onCheckedCrawlResultChange])
 
   const handleRun = useCallback(async (url: string) => {
     const { isValid, errorMsg } = checkValid(url)
     finally {
       setStep(Step.finished)
     }
-  }, [checkValid, crawlOptions, onJobIdChange, t, waitForCrawlFinished])
+  }, [checkValid, crawlOptions, onCheckedCrawlResultChange, onJobIdChange, t, waitForCrawlFinished])
 
   return (
     <div>

web/app/components/datasets/documents/detail/embedding/index.tsx

       await sleep(2500)
       await startQueryStatus()
     }
-    catch (e) {
+    catch {
       await sleep(2500)
       await startQueryStatus()
     }

web/app/components/datasets/documents/detail/index.tsx

     params: { metadata: 'without' },
   })
 
-  const { data: documentMetadata, error: metadataErr, refetch: metadataMutate } = useDocumentMetadata({
+  const { data: documentMetadata } = useDocumentMetadata({
     datasetId,
     documentId,
     params: { metadata: 'only' },
   }
 
   const isDetailLoading = !documentDetail && !error
-  const isMetadataLoading = !documentMetadata && !metadataErr
 
   const embedding = ['queuing', 'indexing', 'paused'].includes((documentDetail?.display_status || '').toLowerCase())
 

web/app/components/datasets/hit-testing/components/child-chunks-item.tsx

   payload,
   isShowAll,
 }) => {
-  const { id, score, content, position } = payload
+  const { score, content, position } = payload
   return (
     <div
       className={!isShowAll ? 'line-clamp-2 break-all' : ''}

web/app/components/datasets/rename-modal/index.tsx

         onSuccess()
       onClose()
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
     finally {

web/app/components/datasets/settings/form/index.tsx

         mutate(unstable_serialize(getKey))
       }
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
     finally {

web/app/components/explore/app-list/index.tsx

       localStorage.setItem(NEED_REFRESH_APP_LIST_KEY, '1')
       getRedirection(isCurrentWorkspaceEditor, { id: app.app_id!, mode }, push)
     }
-    catch (e) {
+    catch {
       Toast.notify({ type: 'error', message: t('app.newApp.appCreateFailed') })
     }
   }

web/app/components/header/account-about/index.tsx

   langeniusVersionInfo: LangGeniusVersionResponse
   onCancel: () => void
 }
-const buttonClassName = `
-shrink-0 flex items-center h-8 px-3 rounded-lg border border-gray-200
-text-xs text-gray-800 font-medium
-`
+
 export default function AccountAbout({
   langeniusVersionInfo,
   onCancel,

web/app/components/header/account-dropdown/workplace-selector/index.tsx

       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       location.assign(`${location.origin}`)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('common.provider.saveFailed') })
     }
   }

web/app/components/header/account-setting/data-source-page/index.tsx

 import useSWR from 'swr'
-import { useTranslation } from 'react-i18next'
 import DataSourceNotion from './data-source-notion'
 import DataSourceWebsite from './data-source-website'
 import { fetchDataSource } from '@/service/common'
 import { DataSourceProvider } from '@/models/common'
 
 export default function DataSourcePage() {
-  const { t } = useTranslation()
   const { data } = useSWR({ url: 'data-source/integrates' }, fetchDataSource)
   const notionWorkspaces = data?.data.filter(item => item.provider === 'notion') || []
 

web/app/components/header/account-setting/members-page/edit-workspace-modal/index.tsx

 }: IEditWorkspaceModalProps) => {
   const { t } = useTranslation()
   const { notify } = useContext(ToastContext)
-  const { currentWorkspace, isCurrentWorkspaceOwner, mutateCurrentWorkspace } = useAppContext()
+  const { currentWorkspace, isCurrentWorkspaceOwner } = useAppContext()
   const [name, setName] = useState<string>(currentWorkspace.name)
 
   const changeWorkspaceInfo = async (name: string) => {
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
       location.assign(`${location.origin}`)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     }
   }

web/app/components/header/account-setting/members-page/invite-modal/index.tsx

           onSend(invitation_results)
         }
       }
-      catch (e) { }
+      catch { }
     }
     else {
       notify({ type: 'error', message: t('common.members.emailInvalid') })

web/app/components/header/account-setting/members-page/operation/index.tsx

       onOperate()
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
     }
-    catch (e) {
+    catch {
 
     }
   }
       onOperate()
       notify({ type: 'success', message: t('common.actionMsg.modifiedSuccessfully') })
     }
-    catch (e) {
+    catch {
 
     }
   }

web/app/components/header/account-setting/model-provider-page/model-parameter-modal/index.tsx

   renderTrigger,
   readonly,
   isInWorkflow,
-  scope = 'text-generation',
 }) => {
   const { t } = useTranslation()
   const { isAPIKeySet } = useProviderContext()

web/app/components/plugins/install-plugin/install-from-github/index.tsx

         })
       }
     }
-    catch (error) {
+    catch {
       Toast.notify({
         type: 'error',
         message: t('plugin.error.fetchReleasesError'),

web/app/components/plugins/plugin-page/index.tsx

     try {
       return idStrings ? JSON.parse(idStrings)[0] : ''
     }
-    catch (e) {
+    catch {
       return ''
     }
   }, [searchParams])
     try {
       return info ? JSON.parse(info) : undefined
     }
-    catch (e) {
+    catch {
       return undefined
     }
   }, [searchParams])

web/app/components/share/utils.ts

   try {
     accessTokenJson = JSON.parse(accessToken)
   }
-  catch (e) {
+  catch {
 
   }
   if (!accessTokenJson[sharedToken]) {
   try {
     accessTokenJson = JSON.parse(accessToken)
   }
-  catch (e) {
+  catch {
 
   }
 
   try {
     accessTokenJson = JSON.parse(accessToken)
   }
-  catch (e) {
+  catch {
 
   }
 

web/app/components/swr-initor.tsx

 
         setInit(true)
       }
-      catch (error) {
+      catch {
         router.replace('/signin')
       }
     })()

web/app/components/tools/edit-custom-collection-modal/index.tsx

         setCustomCollection(newCollection)
         setParamsSchemas(parameters_schema)
       }
-      catch (e) {
+      catch {
         const customCollection = getCustomCollection()
         const newCollection = produce(customCollection, (draft) => {
           draft.schema_type = ''
       const path = decodeURI(new URL(url).pathname)
       return path || ''
     }
-    catch (e) {
+    catch {
       return url
     }
   }

web/app/components/tools/edit-custom-collection-modal/modal.tsx

         setCustomCollection(newCollection)
         setParamsSchemas(parameters_schema)
       }
-      catch (e) {
+      catch {
         const customCollection = getCustomCollection()
         const newCollection = produce(customCollection, (draft) => {
           draft.schema_type = ''
       const path = decodeURI(new URL(url).pathname)
       return path || ''
     }
-    catch (e) {
+    catch {
       return url
     }
   }

web/app/components/tools/provider/detail.tsx

         setToolList(list)
       }
     }
-    catch (e) { }
+    catch { }
     setIsDetailLoading(false)
   }, [collection.name, collection.type])
 

web/app/components/workflow/hooks/use-workflow-interactions.ts

       a.download = `${appDetail.name}.yml`
       a.click()
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.exportFailed') })
     }
     finally {
         },
       } as any)
     }
-    catch (e) {
+    catch {
       notify({ type: 'error', message: t('app.exportFailed') })
     }
   }, [appDetail, eventEmitter, handleExportDSL, notify, t])

web/app/components/workflow/nodes/_base/components/before-run-form/index.tsx

           const value = formatValue(form.values[input.variable], input.type)
           submitData[input.variable] = value
         }
-        catch (e) {
+        catch {
           parseErrorJsonField = input.variable
         }
       })

web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx

     try {
       return JSON.stringify(value as object, null, 2)
     }
-    catch (e) {
+    catch {
       return value as string
     }
   })()

web/app/components/workflow/nodes/code/utils.ts

-import type { CodeNodeType } from './types'
-
-export const checkNodeValid = (payload: CodeNodeType) => {
+export const checkNodeValid = () => {
   return true
 }

web/app/components/workflow/nodes/if-else/components/condition-files-list-value.tsx

         : ''
     }
     return ''
-  }, [])
+  }, [t])
 
   return (
     <div className='rounded-md bg-workflow-block-parma-bg'>

web/app/components/workflow/nodes/if-else/components/condition-list/condition-item.tsx

       value: isArrayValue ? [value] : value,
     }
     doUpdateCondition(newCondition)
-  }, [condition, doUpdateCondition, fileAttr])
+  }, [condition, doUpdateCondition, isArrayValue])
 
   const isSelect = condition.comparison_operator && [ComparisonOperator.in, ComparisonOperator.notIn].includes(condition.comparison_operator)
   const selectOptions = useMemo(() => {

web/app/components/workflow/nodes/if-else/use-config.ts

     })
     setInputs(newInputs)
     updateNodeInternals(id)
-  }, [inputs, setInputs])
+  }, [id, inputs, setInputs, updateNodeInternals])
 
   const handleAddCondition = useCallback<HandleAddCondition>((caseId, valueSelector, varItem) => {
     const newInputs = produce(inputs, (draft) => {

web/app/components/workflow/nodes/question-classifier/utils.ts

-import type { QuestionClassifierNodeType } from './types'
-
-export const checkNodeValid = (payload: QuestionClassifierNodeType) => {
+export const checkNodeValid = () => {
   return true
 }

web/app/components/workflow/note-node/note-editor/context.tsx

   try {
     initialValue = JSON.parse(value)
   }
-  catch (e) {
+  catch {
 
   }
 

web/app/components/workflow/panel/chat-record/index.tsx

         setChatItemTree(tree)
         setThreadChatItems(getThreadMessages(tree, newAllChatItems.at(-1)?.id))
       }
-      catch (e) {
+      catch {
       }
       finally {
         setFetched(true)

web/app/components/workflow/panel/chat-variable-panel/components/variable-modal.tsx

             })
             setObjectValue(newObjectValue)
           }
-          catch (e) {
+          catch {
             // ignore JSON.parse errors
           }
         }
         const newValue = JSON.parse(content)
         setValue(newValue)
       }
-      catch (e) {
+      catch {
         // ignore JSON.parse errors
       }
     }

web/app/components/workflow/panel/global-variable-panel/index.tsx

 } from 'react'
 
 import { RiCloseLine } from '@remixicon/react'
-import { useTranslation } from 'react-i18next'
 import type { GlobalVariable } from '../../types'
 import Item from './item'
 import { useStore } from '@/app/components/workflow/store'
 import cn from '@/utils/classnames'
 
 const Panel = () => {
-  const { t } = useTranslation()
   const setShowPanel = useStore(s => s.setShowGlobalVariablePanel)
 
   const globalVariableList: GlobalVariable[] = [

web/app/forgot-password/ChangePasswordForm.tsx

     catch {
       await revalidateToken()
     }
-  }, [password, revalidateToken, token, valid])
+  }, [confirmPassword, password, revalidateToken, searchParams, valid])
 
   return (
     <div className={

web/app/forgot-password/ForgotPasswordForm.tsx

   fetchSetupStatus,
   sendForgotPasswordEmail,
 } from '@/service/common'
-import type { InitValidateStatusResponse, SetupStatusResponse } from '@/models/common'
+import type { InitValidateStatusResponse } from '@/models/common'
 
 const accountFormSchema = z.object({
   email: z
   }
 
   useEffect(() => {
-    fetchSetupStatus().then((res: SetupStatusResponse) => {
+    fetchSetupStatus().then(() => {
       fetchInitValidateStatus().then((res: InitValidateStatusResponse) => {
         if (res.status === 'not_started')
           window.location.href = '/init'

web/i18n/auto-gen-i18n.js

           const { translation } = await translate(sourceObj[key], null, languageKeyMap[toLanguage])
           targetObject[key] = translation
         }
-        catch (e) {
+        catch {
           console.error(`Error translating ${sourceObj[key]}(${key}) to ${toLanguage}`)
         }
       }

web/service/base.ts

             try {
               bufferObj = JSON.parse(message.substring(6)) as Record<string, any>// remove data: and parse as json
             }
-            catch (e) {
+            catch {
               // mute handle message cut off
               onData('', isFirstMessage, {
                 conversationId: bufferObj?.conversation_id,

web/service/fetch.ts

     try {
       accessTokenJson = JSON.parse(accessToken)
     }
-    catch (e) {
+    catch {
 
     }
     return accessTokenJson[sharedToken]

web/service/refresh-token.ts

 
 let isRefreshing = false
 function waitUntilTokenRefreshed() {
-  return new Promise<void>((resolve, reject) => {
+  return new Promise<void>((resolve) => {
     function _check() {
       const isRefreshingSign = globalThis.localStorage.getItem(LOCAL_STORAGE_KEY)
       if ((isRefreshingSign && isRefreshingSign === '1') || isRefreshing) {

web/service/use-plugins.ts

         const modelsData = await fetchModelProviderModelList(`/workspaces/current/model-providers/${currentProvider?.provider}/models`)
         return !!modelId && !!modelsData.data.find(item => item.model === modelId)
       }
-      catch (error) {
+      catch {
         return false
       }
     },
         const response = await fetchPluginInfoFromMarketPlace({ org, name })
         return response.data.plugin.category === PluginTypeEnum.model ? response.data.plugin : null
       }
-      catch (error) {
+      catch {
         return null
       }
     },