chore(web): strong typing (#2339)

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

     (async () => {
       setIsLoading(true)
       try {
-        const list = await fetchBuiltInToolList(collection.name) as Tool[]
+        const list = await fetchBuiltInToolList(collection.name)
         setTools(list)
         const currTool = list.find(tool => tool.name === toolName)
         if (currTool) {

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

 
   useEffect(() => {
     (async () => {
-      const collectionList = await fetchCollectionList() as Collection[]
+      const collectionList = await fetchCollectionList()
       setCollectionList(collectionList)
       fetchAppDetail({ url: '/apps', id: appId }).then(async (res: any) => {
         setMode(res.mode)

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

     (async () => {
       const customCollection = getCustomCollection()
       try {
-        const { parameters_schema, schema_type } = await parseParamsSchema(debouncedSchema) as any
+        const { parameters_schema, schema_type } = await parseParamsSchema(debouncedSchema)
         const newCollection = produce(customCollection, (draft) => {
           draft.schema_type = schema_type
         })

web/app/components/tools/index.tsx

   const [isDetailLoading, setIsDetailLoading] = useState(false)
 
   const fetchCollectionList = async () => {
-    const list = await doFetchCollectionList() as Collection[]
+    const list = await doFetchCollectionList()
     setCollectionList(list)
     if (list.length > 0 && currCollectionIndex === null) {
       let index = 0
       setIsDetailLoading(true)
       try {
         if (currCollection.type === CollectionType.builtIn) {
-          const list = await fetchBuiltInToolList(currCollection.name) as Tool[]
+          const list = await fetchBuiltInToolList(currCollection.name)
           setCurrentTools(list)
         }
         else {
-          const list = await fetchCustomToolList(currCollection.name) as Tool[]
+          const list = await fetchCustomToolList(currCollection.name)
           setCurrentTools(list)
         }
       }

web/app/components/tools/setting/build-in/config-credentials.tsx

   const { team_credentials: credentialValue, name: collectionName } = collection
   useEffect(() => {
     fetchBuiltInToolCredentialSchema(collectionName).then((res) => {
-      setCredentialSchema(toolCredentialToFormSchemas(res as any))
+      setCredentialSchema(toolCredentialToFormSchemas(res))
     })
   }, [])
   const [tempCredential, setTempCredential] = React.useState<any>(credentialValue)

web/app/components/tools/tool-list/index.tsx

       return
     (async () => {
       if (collection.type === CollectionType.custom) {
-        const res = await fetchCustomCollection(collection.name) as any
+        const res = await fetchCustomCollection(collection.name)
         setCustomCollection({
           ...res,
           provider: collection.name,
-        } as CustomCollectionBackend)
+        })
       }
     })()
   }, [collection])

web/service/billing.ts

 import type { CurrentPlanInfoBackend, SubscriptionUrlsBackend } from '@/app/components/billing/type'
 
 export const fetchCurrentPlanInfo = () => {
-  return get<Promise<CurrentPlanInfoBackend>>('/features')
+  return get<CurrentPlanInfoBackend>('/features')
 }
 
 export const fetchSubscriptionUrls = (plan: string, interval: string) => {
-  return get<Promise<SubscriptionUrlsBackend>>(`/billing/subscription?plan=${plan}&interval=${interval}`)
+  return get<SubscriptionUrlsBackend>(`/billing/subscription?plan=${plan}&interval=${interval}`)
 }
 
 export const fetchBillingUrl = () => {
-  return get<Promise<{ url: string }>>('/billing/invoices')
+  return get<{ url: string }>('/billing/invoices')
 }

web/service/tools.ts

 import { get, post } from './base'
-import type { CustomCollectionBackend } from '@/app/components/tools/types'
+import type { Collection, CustomCollectionBackend, CustomParamSchema, Tool, ToolCredential } from '@/app/components/tools/types'
 
 export const fetchCollectionList = () => {
-  return get('/workspaces/current/tool-providers')
+  return get<Collection[]>('/workspaces/current/tool-providers')
 }
 
 export const fetchBuiltInToolList = (collectionName: string) => {
-  return get(`/workspaces/current/tool-provider/builtin/${collectionName}/tools`)
+  return get<Tool[]>(`/workspaces/current/tool-provider/builtin/${collectionName}/tools`)
 }
 
 export const fetchCustomToolList = (collectionName: string) => {
-  return get(`/workspaces/current/tool-provider/api/tools?provider=${collectionName}`)
+  return get<Tool[]>(`/workspaces/current/tool-provider/api/tools?provider=${collectionName}`)
 }
 export const fetchBuiltInToolCredentialSchema = (collectionName: string) => {
-  return get(`/workspaces/current/tool-provider/builtin/${collectionName}/credentials_schema`)
+  return get<ToolCredential[]>(`/workspaces/current/tool-provider/builtin/${collectionName}/credentials_schema`)
 }
 
 export const updateBuiltInToolCredential = (collectionName: string, credential: Record<string, any>) => {
 }
 
 export const parseParamsSchema = (schema: string) => {
-  return post('/workspaces/current/tool-provider/api/schema', {
+  return post<{ parameters_schema: CustomParamSchema[]; schema_type: string }>('/workspaces/current/tool-provider/api/schema', {
     body: {
       schema,
     },
 }
 
 export const fetchCustomCollection = (collectionName: string) => {
-  return get(`/workspaces/current/tool-provider/api/get?provider=${collectionName}`)
+  return get<CustomCollectionBackend>(`/workspaces/current/tool-provider/api/get?provider=${collectionName}`)
 }
 
 export const createCustomCollection = (collection: CustomCollectionBackend) => {