checklist for tool

web/app/components/plugins/plugin-detail-panel/tool-selector/index.tsx

@@ -131,6 +131,7 @@ const ToolSelector: FC<Props> = ({
       extra: {
         description: '',
       },
+      schemas: tool.paramSchemas,
     }
     onSelect(toolValue)
     // setIsShowChooseTool(false)

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

@@ -184,7 +184,7 @@ export const useChecklistBeforePublish = () => {
     }
 
     return true
-  }, [nodesExtraData, notify, t, store, isChatMode, buildInTools, customTools, workflowTools, language])
+  }, [store, isChatMode, notify, t, buildInTools, customTools, workflowTools, language, nodesExtraData, strategyProviders])
 
   return {
     handleCheckBeforePublish,

web/app/components/workflow/nodes/_base/components/agent-strategy.tsx

@@ -142,7 +142,7 @@ export const AgentStrategy = memo((props: AgentStrategyProps) => {
   ]
   const renderField: ComponentProps<typeof Form<CustomField>>['customRenderField'] = (schema, props) => {
     switch (schema.type) {
-      case 'tool-selector': {
+      case FormTypeEnum.toolSelector: {
         const value = props.value[schema.variable]
         const onChange = (value: any) => {
           props.onChange({ ...props.value, [schema.variable]: value })
@@ -166,7 +166,7 @@ export const AgentStrategy = memo((props: AgentStrategyProps) => {
           </Field>
         )
       }
-      case 'array[tools]': {
+      case FormTypeEnum.multiToolSelector: {
         const value = props.value[schema.variable]
         const onChange = (value: any) => {
           props.onChange({ ...props.value, [schema.variable]: value })

web/app/components/workflow/nodes/agent/default.ts

@@ -2,6 +2,7 @@ import type { StrategyDetail, StrategyPluginDetail } from '@/app/components/plug
 import { ALL_CHAT_AVAILABLE_BLOCKS, ALL_COMPLETION_AVAILABLE_BLOCKS } from '../../constants'
 import type { NodeDefault } from '../../types'
 import type { AgentNodeType } from './types'
+import { FormTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
 import { renderI18nObject } from '@/hooks/use-i18n'
 
 const nodeDefault: NodeDefault<AgentNodeType> = {
@@ -37,6 +38,94 @@ const nodeDefault: NodeDefault<AgentNodeType> = {
       }
     }
     for (const param of strategy.parameters) {
+      // single tool
+      if (param.required && param.type === FormTypeEnum.toolSelector) {
+        // no value
+        const toolValue = payload.agent_parameters?.[param.name]?.value
+        if (!toolValue) {
+          return {
+            isValid: false,
+            errorMessage: t('workflow.errorMsg.fieldRequired', { field: renderI18nObject(param.label, language) }),
+          }
+        }
+        // not enabled
+        else if (!toolValue.enabled) {
+          return {
+            isValid: false,
+            errorMessage: t('workflow.errorMsg.noValidTool', { field: renderI18nObject(param.label, language) }),
+          }
+        }
+        // check form of tool
+        else {
+          const schemas = toolValue.schemas
+          const userSettings = toolValue.settings
+          const reasoningConfig = toolValue.parameters
+          schemas.forEach((schema: any) => {
+            if (schema.required) {
+              if (schema.form === 'form' && !userSettings[schema.name]?.value) {
+                return {
+                  isValid: false,
+                  errorMessage: t('workflow.errorMsg.toolParameterRequired', { field: renderI18nObject(param.label, language), param: renderI18nObject(schema.label, language) }),
+                }
+              }
+              if (schema.form === 'llm' && reasoningConfig[schema.name].auto === 0 && !userSettings[schema.name]?.value) {
+                return {
+                  isValid: false,
+                  errorMessage: t('workflow.errorMsg.toolParameterRequired', { field: renderI18nObject(param.label, language), param: renderI18nObject(schema.label, language) }),
+                }
+              }
+            }
+          })
+        }
+      }
+      // multiple tools
+      if (param.required && param.type === FormTypeEnum.multiToolSelector) {
+        const tools = payload.agent_parameters?.[param.name]?.value || []
+        // no value
+        if (!tools.length) {
+          return {
+            isValid: false,
+            errorMessage: t('workflow.errorMsg.fieldRequired', { field: renderI18nObject(param.label, language) }),
+          }
+        }
+        // not enabled
+        else if (tools.every((tool: any) => !tool.enabled)) {
+          return {
+            isValid: false,
+            errorMessage: t('workflow.errorMsg.noValidTool', { field: renderI18nObject(param.label, language) }),
+          }
+        }
+        // check form of tools
+        else {
+          let validState = {
+            isValid: true,
+            errorMessage: '',
+          }
+          for (const tool of tools) {
+            const schemas = tool.schemas
+            const userSettings = tool.settings
+            const reasoningConfig = tool.parameters
+            schemas.forEach((schema: any) => {
+              if (schema.required) {
+                if (schema.form === 'form' && !userSettings[schema.name]?.value) {
+                  return validState = {
+                    isValid: false,
+                    errorMessage: t('workflow.errorMsg.toolParameterRequired', { field: renderI18nObject(param.label, language), param: renderI18nObject(schema.label, language) }),
+                  }
+                }
+                if (schema.form === 'llm' && reasoningConfig[schema.name]?.auto === 0 && !reasoningConfig[schema.name]?.value) {
+                  return validState = {
+                    isValid: false,
+                    errorMessage: t('workflow.errorMsg.toolParameterRequired', { field: renderI18nObject(param.label, language), param: renderI18nObject(schema.label, language) }),
+                  }
+                }
+              }
+            })
+          }
+          return validState
+        }
+      }
+      // common params
       if (param.required && !payload.agent_parameters?.[param.name]?.value) {
         return {
           isValid: false,

web/i18n/en-US/workflow.ts

@@ -195,6 +195,8 @@ const translation = {
       visionVariable: 'Vision Variable',
     },
     invalidVariable: 'Invalid variable',
+    noValidTool: '{{field}} no valid tool selected',
+    toolParameterRequired: '{{field}}: parameter [{{param}}] is required',
   },
   singleRun: {
     testRun: 'Test Run ',

web/i18n/zh-Hans/workflow.ts

@@ -195,6 +195,9 @@ const translation = {
       visionVariable: '视觉变量',
     },
     invalidVariable: '无效的变量',
+    noValidTool: '{{field}} 无可用工具',
+    toolParameterRequired: '{{field}}: 参数 [{{param}}] 不能为空',
+
   },
   singleRun: {
     testRun: '测试运行 ',