refactor: type improvements that doesn't modify functionality (#17970)

web/app/(commonLayout)/app/(appDetailLayout)/[appId]/overview/tracing/config-popup.tsx

   )
 
   const configuredProviderPanel = () => {
-    const configuredPanels: any[] = []
+    const configuredPanels: JSX.Element[] = []
 
     if (langSmithConfig)
       configuredPanels.push(langSmithPanel)
   }
 
   const moreProviderPanel = () => {
-    const notConfiguredPanels: any[] = []
+    const notConfiguredPanels: JSX.Element[] = []
 
     if (!langSmithConfig)
       notConfiguredPanels.push(langSmithPanel)

web/app/components/app/configuration/config/agent/agent-tools/index.tsx

     formattingChangedDispatcher()
   }
 
-  const handleToolAuthSetting = (value: any) => {
+  const handleToolAuthSetting = (value: AgentToolWithMoreInfo) => {
     const newModelConfig = produce(modelConfig, (draft) => {
       const tool = (draft.agentConfig.tools).find((item: any) => item.provider_id === value?.collection?.id && item.tool_name === value?.tool_name)
       if (tool)
         }
         headerRight={
           <div className='flex items-center'>
-            <div className='text-xs font-normal leading-[18px] text-text-tertiary'>{tools.filter((item: any) => !!item.enabled).length}/{tools.length}&nbsp;{t('appDebug.agent.tools.enabled')}</div>
+            <div className='text-xs font-normal leading-[18px] text-text-tertiary'>{tools.filter(item => !!item.enabled).length}/{tools.length}&nbsp;{t('appDebug.agent.tools.enabled')}</div>
             {tools.length < MAX_TOOLS_NUM && (
               <>
                 <div className='ml-3 mr-1 h-3.5 w-px bg-divider-regular'></div>
       {isShowSettingTool && (
         <SettingBuiltInTool
           toolName={currentTool?.tool_name as string}
-          setting={currentTool?.tool_parameters as any}
+          setting={currentTool?.tool_parameters}
           collection={currentTool?.collection as Collection}
           isBuiltIn={currentTool?.collection?.type === CollectionType.builtIn}
           isModel={currentTool?.collection?.type === CollectionType.model}
               type: 'success',
               message: t('common.api.actionSuccess'),
             })
-            handleToolAuthSetting(currentTool as any)
+            handleToolAuthSetting(currentTool)
             setShowSettingAuth(false)
           }}
         />

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

   const [tools, setTools] = useState<Tool[]>([])
   const currTool = tools.find(tool => tool.name === toolName)
   const formSchemas = currTool ? toolParametersToFormSchemas(currTool.parameters) : []
-  const infoSchemas = formSchemas.filter((item: any) => item.form === 'llm')
-  const settingSchemas = formSchemas.filter((item: any) => item.form !== 'llm')
+  const infoSchemas = formSchemas.filter(item => item.form === 'llm')
+  const settingSchemas = formSchemas.filter(item => item.form !== 'llm')
   const hasSetting = settingSchemas.length > 0
   const [tempSetting, setTempSetting] = useState(setting)
   const [currType, setCurrType] = useState('info')
 
   const isValid = (() => {
     let valid = true
-    settingSchemas.forEach((item: any) => {
+    settingSchemas.forEach((item) => {
       if (item.required && !tempSetting[item.name])
         valid = false
     })
     <div className=''>
       {infoSchemas.length > 0 && (
         <div className='space-y-1 py-2'>
-          {infoSchemas.map((item: any, index) => (
+          {infoSchemas.map((item, index) => (
             <div key={index} className='py-1'>
               <div className='flex items-center gap-2'>
                 <div className='code-sm-semibold text-text-secondary'>{item.label[language]}</div>
     <Form
       value={tempSetting}
       onChange={setTempSetting}
-      formSchemas={settingSchemas as any}
+      formSchemas={settingSchemas}
       isEditMode={false}
       showOnVariableMap={{}}
       validating={false}

web/app/components/app/configuration/dataset-config/params-config/config-content.tsx

             provider={model?.provider}
             completionParams={model?.completion_params}
             modelId={model?.name}
-            setModel={onSingleRetrievalModelChange as any}
-            onCompletionParamsChange={onSingleRetrievalModelParamsChange as any}
+            setModel={onSingleRetrievalModelChange}
+            onCompletionParamsChange={onSingleRetrievalModelParamsChange}
             hideDebugWithMultipleModel
             debugWithMultipleModel={false}
           />

web/app/components/app/configuration/debug/debug-with-multiple-model/model-parameter-trigger.tsx

 import ModelIcon from '@/app/components/header/account-setting/model-provider-page/model-icon'
 import ModelName from '@/app/components/header/account-setting/model-provider-page/model-name'
 import {
+  type FormValue,
   MODEL_STATUS_TEXT,
   ModelStatusEnum,
 } from '@/app/components/header/account-setting/model-provider-page/declarations'
     }
     onMultipleModelConfigsChange(true, newModelConfigs)
   }
-  const handleParamsChange = (params: any) => {
+  const handleParamsChange = (params: FormValue) => {
     const newModelConfigs = [...multipleModelConfigs]
     newModelConfigs[index] = {
       ...newModelConfigs[index],

web/app/components/app/configuration/index.tsx

   }, [modelModeType])
 
   const [dataSets, setDataSets] = useState<DataSet[]>([])
-  const contextVar = modelConfig.configs.prompt_variables.find((item: any) => item.is_context_var)?.key
+  const contextVar = modelConfig.configs.prompt_variables.find(item => item.is_context_var)?.key
   const hasSetContextVar = !!contextVar
   const [isShowSelectDataSet, { setTrue: showSelectDataSet, setFalse: hideSelectDataSet }] = useBoolean(false)
   const selectedIds = dataSets.map(item => item.id)
     formattingChangedDispatcher()
     let newDatasets = data
     if (data.find(item => !item.name)) { // has not loaded selected dataset
-      const newSelected = produce(data, (draft: any) => {
+      const newSelected = produce(data, (draft) => {
         data.forEach((item, index) => {
           if (!item.name) { // not fetched database
             const newItem = dataSets.find(i => i.id === item.id)
           if (modelConfig.chat_prompt_config && modelConfig.chat_prompt_config.prompt.length > 0)
             setChatPromptConfig(modelConfig.chat_prompt_config)
           else
-            setChatPromptConfig(clone(DEFAULT_CHAT_PROMPT_CONFIG) as any)
+            setChatPromptConfig(clone(DEFAULT_CHAT_PROMPT_CONFIG))
           setCompletionPromptConfig(modelConfig.completion_prompt_config || clone(DEFAULT_COMPLETION_PROMPT_CONFIG) as any)
           setCanReturnToSimpleMode(false)
         }

web/app/components/app/configuration/prompt-value-panel/index.tsx

   }
 
   const onClear = () => {
-    const newInputs: Record<string, any> = {}
+    const newInputs: Inputs = {}
     promptVariables.forEach((item) => {
       newInputs[item.key] = ''
     })

web/app/components/base/agent-log-modal/detail.tsx

   const [list, setList] = useState<AgentIteration[]>([])
 
   const tools = useMemo(() => {
-    const res = uniq(flatten(runDetail?.iterations.map((iteration: any) => {
+    const res = uniq(flatten(runDetail?.iterations.map((iteration) => {
       return iteration.tool_calls.map((tool: any) => tool.tool_name).filter(Boolean)
     })).filter(Boolean))
     return res

web/app/components/base/audio-btn/index.tsx

 
   const params = useParams()
   const pathname = usePathname()
-  const audio_finished_call = (event: string): any => {
+  const audio_finished_call = (event: string): void => {
     switch (event) {
       case 'ended':
         setAudioState('ended')

web/app/components/base/chat/chat/hooks.ts

           responseItem.workflowProcess!.tracing!.push({
             ...iterationStartedData,
             status: WorkflowRunningStatus.Running,
-          } as any)
+          })
           updateCurrentQAOnTree({
             placeholderQuestionId,
             questionItem,
             ...tracing[iterationIndex],
             ...iterationFinishedData,
             status: WorkflowRunningStatus.Succeeded,
-          } as any
+          }
 
           updateCurrentQAOnTree({
             placeholderQuestionId,
           responseItem.workflowProcess!.tracing!.push({
             ...nodeStartedData,
             status: WorkflowRunningStatus.Running,
-          } as any)
+          })
           updateCurrentQAOnTree({
             placeholderQuestionId,
             questionItem,
           responseItem.workflowProcess!.tracing!.push({
             ...loopStartedData,
             status: WorkflowRunningStatus.Running,
-          } as any)
+          })
           updateCurrentQAOnTree({
             placeholderQuestionId,
             questionItem,
             ...tracing[loopIndex],
             ...loopFinishedData,
             status: WorkflowRunningStatus.Succeeded,
-          } as any
+          }
 
           updateCurrentQAOnTree({
             placeholderQuestionId,

web/app/components/base/features/new-feature-panel/annotation-reply/index.tsx

 import ConfigParamModal from '@/app/components/base/features/new-feature-panel/annotation-reply/config-param-modal'
 import AnnotationFullModal from '@/app/components/billing/annotation-full/modal'
 import { ANNOTATION_DEFAULT } from '@/config'
+import type { AnnotationReplyConfig } from '@/models/debug'
 
 type Props = {
   disabled?: boolean
   const featuresStore = useFeaturesStore()
   const annotationReply = useFeatures(s => s.features.annotationReply)
 
-  const updateAnnotationReply = useCallback((newConfig: any) => {
+  const updateAnnotationReply = useCallback((newConfig: AnnotationReplyConfig) => {
     const {
       features,
       setFeatures,

web/app/components/base/prompt-editor/plugins/workflow-variable-block/workflow-variable-block-replacement-block.tsx

     }
   }, [])
 
-  const transformListener = useCallback((textNode: any) => {
+  const transformListener = useCallback((textNode: CustomTextNode) => {
     resetReg()
     return decoratorTransform(textNode, getMatch, createWorkflowVariableBlockNode)
   }, [createWorkflowVariableBlockNode, getMatch])

web/app/components/base/toast/index.spec.tsx

+import type { ReactNode } from 'react'
 import React from 'react'
 import { act, render, screen, waitFor } from '@testing-library/react'
 import Toast, { ToastProvider, useToastContext } from '.'
       const CustomToastContext = React.createContext({ notify: noop, close: undefined })
 
       // Create a wrapper component using the custom context
-      const Wrapper = ({ children }: any) => (
+      const Wrapper = ({ children }: { children: ReactNode }) => (
         <CustomToastContext.Provider value={{ notify: noop, close: undefined }}>
           {children}
         </CustomToastContext.Provider>

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

 import cn from '@/utils/classnames'
 import Divider from '@/app/components/base/divider'
 import { ToastContext } from '@/app/components/base/toast'
+import type { IndexingStatusResponse } from '@/models/datasets'
 import { ProcessMode, type ProcessRuleResponse } from '@/models/datasets'
 import type { CommonResponse } from '@/models/common'
 import { asyncRunSafe, sleep } from '@/utils'
   const localDatasetId = dstId ?? datasetId
   const localDocumentId = docId ?? documentId
 
-  const [indexingStatusDetail, setIndexingStatusDetail] = useState<any>(null)
+  const [indexingStatusDetail, setIndexingStatusDetail] = useState<IndexingStatusResponse | null>(null)
   const fetchIndexingStatus = async () => {
     const status = await doFetchIndexingStatus({ datasetId: localDatasetId, documentId: localDocumentId })
     setIndexingStatusDetail(status)

web/app/components/datasets/hit-testing/textarea.tsx

+import type { ChangeEvent } from 'react'
 import React, { useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import {
     setIsSettingsOpen(false)
   }
 
-  function handleTextChange(event: any) {
+  function handleTextChange(event: ChangeEvent<HTMLTextAreaElement>) {
     setText(event.target.value)
   }
 

web/app/components/plugins/marketplace/list/card-wrapper.tsx

         {
           isShowInstallFromMarketplace && (
             <InstallFromMarketplace
-              manifest={plugin as any}
+              manifest={plugin}
               uniqueIdentifier={plugin.latest_package_identifier}
               onClose={hideInstallFromMarketplace}
               onSuccess={hideInstallFromMarketplace}

web/app/components/plugins/plugin-detail-panel/endpoint-card.tsx

       Toast.notify({ type: 'error', message: t('common.actionMsg.modifiedUnsuccessfully') })
     },
   })
-  const handleUpdate = (state: any) => updateEndpoint({
+  const handleUpdate = (state: Record<string, any>) => updateEndpoint({
     endpointID,
     state,
   })

web/app/components/plugins/plugin-detail-panel/endpoint-list.tsx

     },
   })
 
-  const handleCreate = (state: any) => createEndpoint({
+  const handleCreate = (state: Record<string, any>) => createEndpoint({
     pluginUniqueID,
     state,
   })

web/app/components/plugins/plugin-detail-panel/tool-selector/reasoning-config-form.tsx

                 popupClassName='!w-[387px]'
                 isAdvancedMode
                 isInWorkflow
-                value={varInput as any}
+                value={varInput}
                 setModel={handleModelChange(variable)}
                 scope={scope}
               />

web/app/components/plugins/provider-card.tsx

       {
         isShowInstallFromMarketplace && (
           <InstallFromMarketplace
-            manifest={payload as any}
+            manifest={payload}
             uniqueIdentifier={payload.latest_package_identifier}
             onClose={hideInstallFromMarketplace}
             onSuccess={() => hideInstallFromMarketplace()}

web/app/components/share/text-generation/result/index.tsx

                 ...data,
                 status: NodeRunningStatus.Running,
                 expand: true,
-              } as any)
+              })
             }))
           },
           onIterationNext: () => {
               draft.tracing[iterationsIndex] = {
                 ...data,
                 expand: !!data.error,
-              } as any
+              }
             }))
           },
           onLoopStart: ({ data }) => {
                 ...data,
                 status: NodeRunningStatus.Running,
                 expand: true,
-              } as any)
+              })
             }))
           },
           onLoopNext: () => {
               draft.tracing[loopsIndex] = {
                 ...data,
                 expand: !!data.error,
-              } as any
+              }
             }))
           },
           onNodeStarted: ({ data }) => {
                 ...data,
                 status: NodeRunningStatus.Running,
                 expand: true,
-              } as any)
+              })
             }))
           },
           onNodeFinished: ({ data }) => {
                     : {}),
                   ...data,
                   expand: !!data.error,
-                } as any
+                }
               }
             }))
           },

web/app/components/tools/utils/to-form-schema.ts

 }
 
 export const getPlainValue = (value: Record<string, any>) => {
-  const plainValue = { ...value } as any
+  const plainValue = { ...value }
   Object.keys(plainValue).forEach((key) => {
     plainValue[key] = value[key].value
   })

web/app/components/workflow/block-selector/tools.tsx

     }
   }
   */
-  const { letters, groups: withLetterAndGroupViewToolsData } = groupItems(tools, tool => (tool as any).label[language][0])
+  const { letters, groups: withLetterAndGroupViewToolsData } = groupItems(tools, tool => tool.label[language][0])
   const treeViewToolsData = useMemo(() => {
     const result: Record<string, ToolWithProvider[]> = {}
     Object.keys(withLetterAndGroupViewToolsData).forEach((letter) => {

web/app/components/workflow/hooks/use-workflow-run-event/use-workflow-node-finished.ts

       incomeEdges.forEach((edge) => {
         edge.data = {
           ...edge.data,
-          _targetRunningStatus: data.status as any,
+          _targetRunningStatus: data.status,
         }
       })
     })

web/app/components/workflow/hooks/use-workflow-run-event/use-workflow-node-iteration-finished.ts

       incomeEdges.forEach((edge) => {
         edge.data = {
           ...edge.data,
-          _targetRunningStatus: data.status as any,
+          _targetRunningStatus: data.status,
         }
       })
     })

web/app/components/workflow/hooks/use-workflow-run-event/use-workflow-node-loop-finished.ts

       incomeEdges.forEach((edge) => {
         edge.data = {
           ...edge.data,
-          _targetRunningStatus: data.status as any,
+          _targetRunningStatus: data.status,
         }
       })
     })

web/app/components/workflow/nodes/document-extractor/panel.tsx

                   required: true,
                 }],
                 values: { files },
-                onChange: keyValue => setFiles((keyValue as any).files),
+                onChange: keyValue => setFiles(keyValue.files),
               },
             ]}
             runningStatus={runningStatus}

web/app/components/workflow/nodes/iteration/panel.tsx

                 required: false,
               }],
               values: { [iteratorInputKey]: iterator },
-              onChange: keyValue => setIterator((keyValue as any)[iteratorInputKey]),
+              onChange: keyValue => setIterator(keyValue[iteratorInputKey]),
             },
           ]}
           runningStatus={runningStatus}

web/app/components/workflow/nodes/knowledge-retrieval/components/retrieval-config.tsx

             model: configs.reranking_model?.reranking_model_name,
           }),
       reranking_mode: configs.reranking_mode,
-      weights: configs.weights as any,
+      weights: configs.weights,
       reranking_enable: configs.reranking_enable,
     })
   }, [onMultipleRetrievalConfigChange, payload.retrieval_mode, validRerankDefaultProvider, validRerankDefaultModel, onRetrievalModeChange])

web/app/components/workflow/nodes/knowledge-retrieval/panel.tsx

                   required: true,
                 }],
                 values: { query },
-                onChange: keyValue => setQuery((keyValue as any).query),
+                onChange: keyValue => setQuery(keyValue.query),
               },
             ]}
             runningStatus={runningStatus}

web/app/components/workflow/nodes/llm/panel.tsx

             required: false,
           }],
           values: { '#context#': contexts },
-          onChange: keyValue => setContexts((keyValue as any)['#context#']),
+          onChange: keyValue => setContexts(keyValue['#context#']),
         },
       )
     }

web/app/components/workflow/nodes/parameter-extractor/components/extract-parameter/import-from-tool.tsx

     })()
     const currCollection = currentTools.find(item => canFindTool(item.id, provider_id))
     const currTool = currCollection?.tools.find(tool => tool.name === tool_name)
-    const toExactParams = (currTool?.parameters || []).filter((item: any) => item.form === 'llm')
+    const toExactParams = (currTool?.parameters || []).filter(item => item.form === 'llm')
     const formattedParams = toParmExactParams(toExactParams, language)
     onImport(formattedParams)
   }, [buildInTools, customTools, language, onImport, workflowTools])

web/app/components/workflow/nodes/question-classifier/panel.tsx

             required: false,
           }],
           values: { '#files#': visionFiles },
-          onChange: keyValue => setVisionFiles((keyValue as any)['#files#']),
+          onChange: keyValue => setVisionFiles(keyValue['#files#']),
         },
       )
     }

web/app/components/workflow/panel/workflow-preview.tsx

               <ResultText
                 isRunning={workflowRunningData?.result?.status === WorkflowRunningStatus.Running || !workflowRunningData?.result}
                 outputs={workflowRunningData?.resultText}
-                allFiles={workflowRunningData?.result?.files as any}
+                allFiles={workflowRunningData?.result?.files}
                 error={workflowRunningData?.result?.error}
                 onClick={() => switchTab('DETAIL')}
               />

web/app/components/workflow/run/utils/format-log/loop/index.spec.ts

   const [startNode, loopNode, ...loops] = list
   const result = format(list as any, noop)
   test('result should have no nodes in loop node', () => {
-    expect((result as any).find((item: any) => !!item.execution_metadata?.loop_id)).toBeUndefined()
+    expect(result.find(item => !!item.execution_metadata?.loop_id)).toBeUndefined()
   })
   test('loop should put nodes in details', () => {
-    expect(result as any).toEqual([
+    expect(result).toEqual([
       startNode,
       {
         ...loopNode,

web/app/components/workflow/run/utils/format-log/retry/index.spec.ts

   const [startNode, retryNode, ...retryDetail] = steps
   const result = format(steps as any)
   test('should have no retry status nodes', () => {
-    expect(result.find(item => (item as any).status === 'retry')).toBeUndefined()
+    expect(result.find(item => item.status === 'retry')).toBeUndefined()
   })
   test('should put retry nodes in retryDetail', () => {
     expect(result).toEqual([

web/app/components/workflow/utils/tool.ts

   const currCollection = currentTools.find(item => canFindTool(item.id, provider_id))
   const currTool = currCollection?.tools.find(tool => tool.name === tool_name)
   const formSchemas = currTool ? toolParametersToFormSchemas(currTool.parameters) : []
-  const toolInputVarSchema = formSchemas.filter((item: any) => item.form === 'llm')
-  const toolSettingSchema = formSchemas.filter((item: any) => item.form !== 'llm')
+  const toolInputVarSchema = formSchemas.filter(item => item.form === 'llm')
+  const toolSettingSchema = formSchemas.filter(item => item.form !== 'llm')
 
   return {
     toolInputsSchema: (() => {

web/app/education-apply/search-input.tsx

+import type { ChangeEventHandler } from 'react'
 import {
   useCallback,
   useRef,
     })
   }, [querySchoolsWithDebounced, handleUpdateSchools])
 
-  const handleValueChange = useCallback((e: any) => {
+  const handleValueChange: ChangeEventHandler<HTMLInputElement> = useCallback((e) => {
     setOpen(true)
     setSchools([])
     pageRef.current = 0

web/utils/index.spec.ts

 })
 
 describe('getTextWidthWithCanvas', () => {
-  let originalCreateElement: any
+  let originalCreateElement: typeof document.createElement
 
   beforeEach(() => {
     // Store original implementation
 })
 
 describe('removeSpecificQueryParam', () => {
-  let originalLocation: any
-  let originalReplaceState: any
+  let originalLocation: Location
+  let originalReplaceState: typeof window.history.replaceState
 
   beforeEach(() => {
     originalLocation = window.location