diff --git a/ai-flow-front/packages/flow-content/workflow/lib/components/editors/agent-selector/src/composition/use-modal.tsx b/ai-flow-front/packages/flow-content/workflow/lib/components/editors/agent-selector/src/composition/use-modal.tsx
index b4d3daae90e8c5d78bd20d89edce7c4adf996b21..eec4a7cf77566216ee97b0905a0080a71ebb7a12 100644
--- a/ai-flow-front/packages/flow-content/workflow/lib/components/editors/agent-selector/src/composition/use-modal.tsx
+++ b/ai-flow-front/packages/flow-content/workflow/lib/components/editors/agent-selector/src/composition/use-modal.tsx
@@ -42,6 +42,7 @@ export function useModal(
   const treeGridComponentInstance = ref<any>();
   const dataGridRef = ref<any>();
   const agentFilterValue = ref('');
+  let agentDataTotal = 0;
 
   function closeModal(): void {
     if (modalInstance.value) {
@@ -75,19 +76,21 @@ export function useModal(
    * 智能体名称筛选处理
    */
   const onAgentFilterChange = (value: string) => {
+
     agentFilterValue.value = value;
+
     if (!value || value.trim() === '') {
-      filteredAgentData.value = [...agentData.value];
+      fetchAgentList(currentTagId.value, '');
     } else {
       const filterValue = value.toLowerCase().trim();
-      filteredAgentData.value = agentData.value.filter((item: any) =>
-        item.agentName && item.agentName.toLowerCase().includes(filterValue)
-      );
+       pagination.value = {
+        ...pagination.value,
+        index: 1
+      };
+      fetchAgentList(currentTagId.value, filterValue);
     }
-
     // 更新表格数据源并清除选中状态
     if (dataGridRef.value) {
-      dataGridRef.value.updateDataSource(filteredAgentData.value);
       dataGridRef.value.clearSelection?.(); // 清除表格的选中状态
     }
 
@@ -202,6 +205,11 @@ export function useModal(
     // 清空筛选框和选中状态
     agentFilterValue.value = '';
     selectedData.value = [];
+    // 更新分页配置
+    pagination.value = {
+      ...pagination.value,
+      index: 1
+    };
 
     // 获取该分类下的智能体列表
     fetchAgentList(tagId);
@@ -210,28 +218,64 @@ export function useModal(
   // 当前选中的tagId
   const currentTagId = ref<string | null>(null);
 
+  /**
+   * 获取当前语言
+   */
+  const getCurrentLang = () => {
+    const langKey = localStorage.getItem('languageCode');
+    if(langKey === 'zh-CHS') return 'cafMlcchs';
+    if(langKey === 'en') return 'cafMlcen';
+    if(langKey === 'zh-CHT') return 'cafMlccht';
+    return 'cafMlcchs';
+  }
+
   /**
    * 获取智能体列表
    */
-  const fetchAgentList = async (tagId: string | null) => {
+  const fetchAgentList = async (tagId: string | null, agentName: string | null = null) => {
     try {
       const requestData: any = {
         startDateTime: "",
         endDateTime: "",
         orderCondition: "createdOn",
         orderType: "desc",
-        tagId: tagId
+        tagId: tagId,
+        agentName: agentName,
+        page: pagination.value.index - 1,
+        pageSize: pagination.value.size
       };
 
       const res = await post('/runtime/sys/v1.0/aiAgentBuilder/authFilter/agent', requestData);
-
-      if (!res || !Array.isArray(res)) {
+      if (!res) {
         agentData.value = [];
         return;
       }
 
+      // 更新分页配置
+      pagination.value = {
+        ...pagination.value,
+        total: res.pagination.totalCount
+      };
+
+      agentDataTotal = res.pagination.totalCount;
+
+
       // 只展示canEdit为false的智能体
-      agentData.value = res.filter((agent: any) => agent.canEdit === false);
+      // agentData.value = res.resultList.filter((agent: any) => agent.canEdit === false).map((agent: any) => {
+      //   const currentLang = getCurrentLang();
+      //   return {
+      //     ...agent,
+      //     agentName: agent.agentNameI18n?.[currentLang] || ''
+      //   };
+      // });
+      agentData.value = res.resultList.map((agent: any) => {
+        const currentLang = getCurrentLang();
+        return {
+          ...agent,
+          agentName: agent.agentNameI18n?.[currentLang] || '',
+          disabled: agent.canEdit
+        };
+      });
 
       // 应用筛选
       if (!agentFilterValue.value || agentFilterValue.value.trim() === '') {
diff --git a/ai-flow-front/packages/flow-content/workflow/lib/index.ts b/ai-flow-front/packages/flow-content/workflow/lib/index.ts
index 025725b94ac68c2f8b8f73adf10f25441be24fa7..2d0c606c677598650f421f496e73ab7ce62ab560 100644
--- a/ai-flow-front/packages/flow-content/workflow/lib/index.ts
+++ b/ai-flow-front/packages/flow-content/workflow/lib/index.ts
@@ -118,6 +118,7 @@ export const FLOW_REGISTRY: FlowRegistry = {
       BuiltinNodeType.Loop,
       BuiltinNodeType.VariableDef,
       BuiltinNodeType.VariableAssign,
+      BuiltinNodeType.MethodInvoke,
       BuiltinNodeType.End,
     ],
   }],
diff --git a/ai-flow-front/packages/flow-content/workflow/src/mock-data.ts b/ai-flow-front/packages/flow-content/workflow/src/mock-data.ts
index 2a97d3e2116327e3eb7f5639a9443ff975cad268..dbec913ad96e4bb0e14119d658bb7298f3c03e4e 100644
--- a/ai-flow-front/packages/flow-content/workflow/src/mock-data.ts
+++ b/ai-flow-front/packages/flow-content/workflow/src/mock-data.ts
@@ -34,42 +34,7 @@ export const MOCK_FLOW_METADATA: FlowMetadata = {
         inputPorts: [],
         outputPorts: [],
         graphMeta: {
-            position: { x: 80, y: 150 },
-        },
-        extension: {},
-    }, {
-        id: 'llm',
-        kind: 'LLMClient',
-        code: 'llm',
-        name: '大模型',
-        description: '',
-        inputParams: [{
-            code: 'question',
-            type: {
-                source: 'default',
-                typeId: 'string',
-                typeCode: 'String',
-                typeName: 'String',
-            },
-            valueExpr: {
-                kind: 'nodeVariable',
-                nodeCode: 'start',
-                variable: 'keyword',
-            },
-        }],
-        outputParams: [{
-            code: 'result',
-            type: {
-                source: 'default',
-                typeId: 'string',
-                typeCode: 'String',
-                typeName: 'String',
-            },
-        }],
-        inputPorts: [],
-        outputPorts: [],
-        graphMeta: {
-            position: { x: 450, y: 150 },
+            position: { x: 0, y: 0 },
         },
         extension: {},
     }, {
@@ -79,34 +44,16 @@ export const MOCK_FLOW_METADATA: FlowMetadata = {
         name: '结束',
         description: '',
         inputParams: [],
-        outputParams: [{
-            code: 'outline',
-            type: {
-                source: 'default',
-                typeId: 'string',
-                typeCode: 'String',
-                typeName: 'String',
-            },
-            valueExpr: {
-                kind: 'nodeVariable',
-                nodeCode: 'llm',
-                variable: 'result',
-            },
-        }],
+        outputParams: [],
         inputPorts: [],
         outputPorts: [],
         graphMeta: {
-            position: { x: 850, y: 150 },
+            position: { x: 1000, y: 0 },
         },
         extension: {},
     }],
     edges: [{
         sourceNodeId: 'start',
-        targetNodeId: 'llm',
-        sourcePort: 'output',
-        targetPort: 'input',
-    }, {
-        sourceNodeId: 'llm',
         targetNodeId: 'end',
         sourcePort: 'output',
         targetPort: 'input',
diff --git a/ai-flow-front/packages/flow-designer/package.json b/ai-flow-front/packages/flow-designer/package.json
index d9e004d5c52ec9a6e207270fe709e98d9d723fc8..0f42dcb215092aec21eb42af78e94de2852a16b7 100644
--- a/ai-flow-front/packages/flow-designer/package.json
+++ b/ai-flow-front/packages/flow-designer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@farris/flow-designer",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "Apache-2.0",
   "private": true,
   "type": "module",
diff --git a/ai-flow-front/packages/flow-designer/src/assets/images/index.ts b/ai-flow-front/packages/flow-designer/src/assets/images/index.ts
index 578e0935caf3a5fd1ba7fd780e8947a205c78ddf..6fd7f542414d32291fc0cc850e3e2d179ae41689 100644
--- a/ai-flow-front/packages/flow-designer/src/assets/images/index.ts
+++ b/ai-flow-front/packages/flow-designer/src/assets/images/index.ts
@@ -4,3 +4,4 @@ export { default as selectorIcon } from './icon-selector.jpg';
 export { default as loopIcon } from './icon-loop.jpg';
 export { default as variableDefIcon } from './icon-variable-def.jpg';
 export { default as variableAssignIcon } from './icon-variable-assign.jpg';
+export { default as methodInvokeIcon } from './method-invoke.jpg';
diff --git a/ai-flow-front/packages/flow-designer/src/assets/images/method-invoke.jpg b/ai-flow-front/packages/flow-designer/src/assets/images/method-invoke.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..782339fad366fd7268668c0df4bd5cbc79f8cd64
Binary files /dev/null and b/ai-flow-front/packages/flow-designer/src/assets/images/method-invoke.jpg differ
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/index.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/index.ts
index a9828cc2fa967957fec32ea461b0d096ebdfc5f2..e2441d84b9ec3285709d8657a32e83a333b8ef2d 100644
--- a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/index.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/index.ts
@@ -4,6 +4,7 @@ import { SELECTOR_NODE } from './selector';
 import { LOOP_NODE } from './loop';
 import { VARIABLE_DEF_NODE } from './variable-def';
 import { VARIABLE_ASSIGN_NODE } from './variable-assign';
+import { METHOD_INVOKE_NODE } from './method-invoke';
 
 export const BUILTIN_NODES = [
     START_NODE,
@@ -12,4 +13,5 @@ export const BUILTIN_NODES = [
     LOOP_NODE,
     VARIABLE_DEF_NODE,
     VARIABLE_ASSIGN_NODE,
+    METHOD_INVOKE_NODE,
 ];
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/loop/node-definition.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/loop/node-definition.ts
index fa53239120597a1233dea3057365699becc41474..9482ff0c14e0290b297aa44a5b11152fc670cc4a 100644
--- a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/loop/node-definition.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/loop/node-definition.ts
@@ -1,6 +1,6 @@
 import { markRaw } from 'vue';
-import type { NodeDefinition, Parameter, TypeRefer } from '@farris/flow-devkit';
-import { BasicTypeRefer, BuiltinNodeType, ValidateUtils } from '@farris/flow-devkit';
+import type { NodeDefinition, Parameter, TypeRefer, JsonSchema } from '@farris/flow-devkit';
+import { BasicTypeRefer, BuiltinNodeType, ValidateUtils, ValueExpressUtils } from '@farris/flow-devkit';
 import { loopIcon } from '@flow-designer/assets/images';
 import SubFlowNode from './node.component.vue';
 import { NodeProperty } from './property-config';
@@ -12,7 +12,7 @@ export const LOOP_NODE: NodeDefinition = {
         description: '根据循环数组，循环执行一段逻辑',
         icon: loopIcon,
         isSubFlowContainer: true,
-        debuggable: false,  // @todo 单节点调试功能暂不支持识别`inputParams`之外的输入参数，后续需要支持通过回调方法自定义输入参数
+        debuggable: false,
         ports: [
             {
                 id: 'input',
@@ -46,12 +46,25 @@ export const LOOP_NODE: NodeDefinition = {
             writable: false,
         };
         const itemCode = nodeData.iterableVariable || 'item';
-        const itemType = (nodeData.iterableExprType as TypeRefer)?.genericTypes?.[0];
+        let itemType: TypeRefer | undefined = undefined;
+        let itemSchema: JsonSchema | undefined = undefined;
+        if (ValueExpressUtils.isNodeVariableExpr(nodeData.iterableExpr)) {
+            const valueExpressType = ValueExpressUtils.unwrapValueExpressType(
+                ValueExpressUtils.getValueExpressType(nodeData.iterableExpr, nodeData)
+            );
+            if (valueExpressType) {
+                itemType = valueExpressType.type;
+                itemSchema = valueExpressType.schema;
+            }
+        } else {
+            itemType = (nodeData.iterableExprType as TypeRefer)?.genericTypes?.[0];
+        }
         const item = {
             id: `${nodeData.id}_item`,
             code: itemCode,
             name: `${itemCode} (in items)`,
             type: itemType,
+            schema: itemSchema,
             writable: false,
         } as Parameter;
         return [item, index, ...nodeData.outputParams];
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/index.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..218a7bd52ceafb7471837587507af9136e862351
--- /dev/null
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/index.ts
@@ -0,0 +1 @@
+export * from './node-definition';
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node-definition.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node-definition.ts
new file mode 100644
index 0000000000000000000000000000000000000000..20239c47377dd855529b7264d6a5f7677bbfe434
--- /dev/null
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node-definition.ts
@@ -0,0 +1,59 @@
+import { markRaw } from 'vue';
+import type { NodeDefinition, MethodInvokeExpr } from '@farris/flow-devkit';
+import { BuiltinNodeType, ValueExpressUtils, ParameterUtils, useTypeDetails } from '@farris/flow-devkit';
+import { methodInvokeIcon } from '@flow-designer/assets/images';
+import MethodInvokeComponent from './node.component.vue';
+import { NodeProperty } from './property-config';
+
+export const METHOD_INVOKE_NODE: NodeDefinition = {
+    metadata: {
+        type: BuiltinNodeType.MethodInvoke,
+        label: '函数调用',
+        description: '用于调用一个函数',
+        icon: methodInvokeIcon,
+        debuggable: true,
+        ports: [
+            {
+                id: 'input',
+                position: 'left',
+                type: 'target',
+            },
+            {
+                id: 'output',
+                position: 'right',
+                type: 'source',
+            }
+        ]
+    },
+    component: markRaw(MethodInvokeComponent),
+    getPropertyPanelConfig: (nodeData) => {
+        const config = new NodeProperty();
+        return config.getPropertyConfig(nodeData);
+    },
+    validator: (nodeData) => {
+        if (!ValueExpressUtils.isMethodInvokeExpr(nodeData.express)) {
+            return { errors: [{ message: "函数名不可为空" }] };
+        }
+    },
+    getOutputParams: (nodeData) => {
+        const express = nodeData.express as MethodInvokeExpr;
+        const returnType = ValueExpressUtils.getReturnTypeByMethodInvokeExpr(express);
+        if (!returnType || ParameterUtils.isVoid(returnType)) {
+            return [];
+        }
+        const { loadType } = useTypeDetails();
+        loadType(returnType);
+        return [{
+            id: `${nodeData.id}_returnValue`,
+            code: `returnValue`,
+            type: returnType,
+            description: `函数的返回值`,
+            readOnly: true,
+        }];
+    },
+    getDebugParams: (nodeData) => {
+        const express = nodeData.express as MethodInvokeExpr;
+        const method = ValueExpressUtils.getMethodTypeByMethodInvokeExpr(express);
+        return method?.parameters || [];
+    },
+};
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node.component.vue b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node.component.vue
new file mode 100644
index 0000000000000000000000000000000000000000..7362c49c1b4613e8cff29174e4cef8193ded84d3
--- /dev/null
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/node.component.vue
@@ -0,0 +1,75 @@
+<template>
+  <NodeWrapper :nodeProps="props" :width="260">
+    <NodeContentWrapper>
+      <NodeField name="函数名">
+        <div v-if="currentMethod" class="method-label" :title="methodTitle">
+          <span class="method-name">{{ methodName }}</span>
+          <span v-if="methodName !== methodCode" class="method-code">{{ methodCode }}</span>
+        </div>
+        <div v-else class="fvf-node-field-empty" title="未选择函数">未选择函数</div>
+      </NodeField>
+    </NodeContentWrapper>
+  </NodeWrapper>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import type { NodeProps, TypeMethod, MethodInvokeExpr } from '@farris/flow-devkit';
+import { NodeWrapper, NodeContentWrapper, NodeField, ValueExpressUtils } from '@farris/flow-devkit';
+
+const props = defineProps<NodeProps>();
+
+const currentMethod = computed<TypeMethod | undefined>(() => {
+  const currentValue = props.data.express as MethodInvokeExpr;
+  return ValueExpressUtils.getMethodTypeByMethodInvokeExpr(currentValue);
+});
+
+const methodName = computed<string>(() => {
+  const method = currentMethod.value;
+  if (!method) {
+    return '';
+  }
+  return method.name || method.code;
+});
+
+const methodCode = computed<string>(() => {
+  const method = currentMethod.value;
+  if (!method) {
+    return '';
+  }
+  return method.code;
+});
+
+const methodTitle = computed<string>(() => {
+  const method = currentMethod.value;
+  if (!method) {
+    return '';
+  }
+  return `${method.name || method.code} - ${method.code}`;
+});
+</script>
+
+<style scoped lang="scss">
+.method-label {
+  display: block;
+  font-style: normal;
+  font-size: 14px;
+  height: 26px;
+  line-height: 26px;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.method-name {
+  color: rgba(0, 0, 0, 0.75);
+}
+
+.method-code {
+  color: rgba(0, 0, 0, 0.6);
+}
+
+.method-name+.method-code {
+  margin-left: 4px;
+}
+</style>
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/property-config.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/property-config.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0169a18d24069811ad99c517b9f4735fdd14a1b9
--- /dev/null
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/method-invoke/property-config.ts
@@ -0,0 +1,33 @@
+import { BaseControlProperty, type NodeData } from '@farris/flow-devkit';
+
+export class NodeProperty extends BaseControlProperty {
+
+    public getPropertyConfig(nodeData: NodeData) {
+        this.propertyConfig.categories['basic'] = {
+            hideTitle: true,
+            title: "基本信息",
+            description: "Basic Information",
+            properties: {
+                name: {
+                    type: "object",
+                    editor: {
+                        type: 'fvf-node-header',
+                        nodeData,
+                    },
+                }
+            }
+        };
+        this.propertyConfig.categories['express'] = {
+            title: "调用配置",
+            properties: {
+                express: {
+                    type: "object",
+                    editor: {
+                        type: 'fvf-method-invoke-express',
+                    }
+                }
+            }
+        };
+        return this.propertyConfig;
+    }
+}
diff --git a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/start/property-config.ts b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/start/property-config.ts
index 1e223b60dd13c14a4cbb846bd204578df4f10224..57886ca60fe9f6f8076cdcbdd0ecfa48eff59cd0 100644
--- a/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/start/property-config.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/builtin-nodes/start/property-config.ts
@@ -24,6 +24,8 @@ export class NodeProperty extends BaseControlProperty {
                     type: "array",
                     editor: {
                         type: 'fvf-json-schema-editor',
+                        canEditName: true,
+                        canEditInputHelp: true,
                     }
                 }
             }
diff --git a/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-flow-property-panel.tsx b/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-flow-property-panel.tsx
index 2aa0d7365da82957ab3a6cd54034cd9b2d4a6a5e..9bd92693046ee778e6b61276eba4ddda1a77e45d 100644
--- a/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-flow-property-panel.tsx
+++ b/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-flow-property-panel.tsx
@@ -5,6 +5,8 @@ import type { PropertyCategory, PropertyPanelConfig } from '@farris/flow-devkit'
 
 import css from '../flow-view.module.scss';
 
+const PROPERTY_PANEL_DEFAULT_WIDTH = 300;
+
 export function useFlowPropertyPanel() {
 
     const flowRegistry = inject(FLOW_REGISTRY_KEY);
@@ -67,7 +69,7 @@ export function useFlowPropertyPanel() {
         return panelShowMode.value === 'panel';
     });
 
-    const leftPanelWidth = ref<number>(300);
+    const leftPanelWidth = ref<number>(PROPERTY_PANEL_DEFAULT_WIDTH);
 
     const leftPanelStyle = computed<CSSProperties>(() => ({
         display: shouldShowPropertyPanel.value ? undefined : 'none',
@@ -79,7 +81,21 @@ export function useFlowPropertyPanel() {
         categories: {},
     };
 
+    function setPanelWidth(newValue: number): void {
+        leftPanelWidth.value = newValue;
+    }
+
+    function updatePanelWidth(): void {
+        const defaultWidth = flowRegistry?.value?.flowPropertyPanelDefaultWidth;
+        if (typeof defaultWidth === 'number' && defaultWidth > 0) {
+            setPanelWidth(defaultWidth);
+            return;
+        }
+        setPanelWidth(PROPERTY_PANEL_DEFAULT_WIDTH);
+    }
+
     function updatePropertyPanel(forceUpdate = true): void {
+        updatePanelWidth();
         const propertyConfig = getPropertyPanelConfig.value?.(propertyData.value) || defaultPropertyPanelConfig;
         propertyConfig.type = 'object';
         propertyConfig.categories = Object.assign({ _basic_: defaultPropertyCategory }, propertyConfig.categories);
diff --git a/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-node-property-panel.tsx b/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-node-property-panel.tsx
index e3df2911daa2a804740562214b5630925cbcf43b..6aeb2c2211326645351c97eec0e9a686cf6e6fae 100644
--- a/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-node-property-panel.tsx
+++ b/ai-flow-front/packages/flow-designer/src/components/flow-view/composition/use-node-property-panel.tsx
@@ -1,11 +1,11 @@
-import { computed, ref, watch, provide, type CSSProperties, defineComponent, type PropType, type Ref } from 'vue';
+import { computed, ref, watch, provide, inject, type CSSProperties, defineComponent, type PropType, type Ref } from 'vue';
 import { FlowPropertyPanel, type PanelShowMode } from '@flow-designer/components/property-panel';
 import { useVueFlow, type GraphNode } from '@vue-flow/core';
 import { nodeRegistry, PROPERTY_PANEL_KEY, provideNodeVariables } from '@farris/flow-devkit';
 import type { NodeDefinition, NodeMetadata, FlowNodeInstance, NodeData } from '@farris/flow-devkit';
 import { NODE_RENDER_SCENE_KEY, USE_NODE_ID_KEY, USE_NODE_DATA_KEY } from '@farris/flow-devkit';
 import type { UseNodePropertyPanel } from './types';
-import { useFloatPanelLayout } from '@flow-designer/hooks';
+import { useFloatPanelLayout, FLOW_REGISTRY_KEY } from '@flow-designer/hooks';
 
 import styles from '../flow-view.module.scss';
 
@@ -38,6 +38,8 @@ const NodeContextProvider = defineComponent({
     },
 });
 
+const PROPERTY_PANEL_DEFAULT_WIDTH = 450;
+
 export function useNodePropertyPanel(): UseNodePropertyPanel {
 
     const {
@@ -45,6 +47,7 @@ export function useNodePropertyPanel(): UseNodePropertyPanel {
         nodes: allNodes,
         onNodeClick,
     } = useVueFlow();
+    const flowRegistry = inject(FLOW_REGISTRY_KEY);
 
     const isShow = ref(true);
     const propertyPanelInstance = ref();
@@ -94,7 +97,28 @@ export function useNodePropertyPanel(): UseNodePropertyPanel {
         return typeof getPropertyPanelConfig === 'function';
     });
 
+    const rightPanelWidth = ref<number>(PROPERTY_PANEL_DEFAULT_WIDTH);
+
+    function setPanelWidth(newValue: number): void {
+        rightPanelWidth.value = newValue;
+    }
+
+    function updatePanelWidth(): void {
+        const nodeLevelDefaultWidth = selectedNodeDefinition.value?.propertyPanelDefaultWidth;
+        if (typeof nodeLevelDefaultWidth === 'number' && nodeLevelDefaultWidth > 0) {
+            setPanelWidth(nodeLevelDefaultWidth);
+            return;
+        }
+        const flowLevelDefaultWidth = flowRegistry?.value?.nodePropertyPanelDefaultWidth;
+        if (typeof flowLevelDefaultWidth === 'number' && flowLevelDefaultWidth > 0) {
+            setPanelWidth(flowLevelDefaultWidth);
+            return;
+        }
+        setPanelWidth(PROPERTY_PANEL_DEFAULT_WIDTH);
+    }
+
     function updatePropertyPanel(forceUpdate = true): void {
+        updatePanelWidth();
         const nodeId = selectedNode.value?.id;
         const nodeData = selectedNode.value?.data;
         const getPropertyPanelConfig = selectedNodeDefinition.value?.getPropertyPanelConfig;
@@ -138,8 +162,6 @@ export function useNodePropertyPanel(): UseNodePropertyPanel {
         return panelShowMode.value === 'panel';
     });
 
-    const rightPanelWidth = ref<number>(450);
-
     const PANEL_ID = 'NodePropertyPanel';
     const { currentRightFloatPanelId } = useFloatPanelLayout();
     function renderCurrentPanel() {
diff --git a/ai-flow-front/packages/flow-designer/src/components/node-debug-drawer/node-debug-drawer.component.vue b/ai-flow-front/packages/flow-designer/src/components/node-debug-drawer/node-debug-drawer.component.vue
index 44195e472f3d8b563e5e00a787af7da3e3134b90..c514b3ec618357b7686c2004c7274386fb8166dd 100644
--- a/ai-flow-front/packages/flow-designer/src/components/node-debug-drawer/node-debug-drawer.component.vue
+++ b/ai-flow-front/packages/flow-designer/src/components/node-debug-drawer/node-debug-drawer.component.vue
@@ -334,7 +334,7 @@ onUnmounted(() => {
   .tab-item {
     flex: 1;
     text-align: center;
-    padding: 0 14px 7px 14px;
+    padding: 4px 14px 3px 14px;
     cursor: pointer;
     font-size: 14px;
     font-weight: 400;
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/chat-debug.vue b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/chat-debug.vue
index 6bac96802f293edf5c1592e772e4d21acaf7b7f5..2d0d193e64e91364b5032fd8c4e26af4434b8b6c 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/chat-debug.vue
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/chat-debug.vue
@@ -111,7 +111,7 @@
 
 <script setup lang="ts">
 import { ref, onMounted, nextTick, watch } from 'vue';
-import { useNotify } from '@farris/flow-devkit';
+import { useNotify, type NodeData } from '@farris/flow-devkit';
 import ChatMessage from './chat-message/chat-message.component.vue';
 import ParamList from './param-list.vue';
 import {
@@ -126,7 +126,6 @@ import {
 } from './file-upload-utils';
 import { useChatflowApi } from './composables/use-chatflow-api';
 import { useWorkflowApi } from './composables/use-workflow-api';
-import { useInputParams } from './composables/use-input-params';
 import { SSEDataProcessor, SSEDataUtils } from './composables/sse-data-processor';
 import type { GspDocMetadata, InputParam} from './types';
 import type { ChatMessage as EnhancedChatMessage, ChatConfig } from './composables/chat-debug.types';
@@ -139,6 +138,7 @@ interface ChatMessage extends EnhancedChatMessage {
 // 定义组件属性
 interface Props {
   inputParams?: InputParam[];
+  startNodeData?: NodeData;
 }
 
 // 使用属性
@@ -155,7 +155,6 @@ const notifyService = useNotify();
 // 初始化对话流API和工作流API
 const { callChatflowAPI, stopChatflowAPI } = useChatflowApi();
 const { saveWorkflow } = useWorkflowApi();
-const inputParamsComposable = useInputParams();
 
 // 聊天配置
 const chatConfig: ChatConfig = {
@@ -536,7 +535,7 @@ async function sendToChatFlow(content: string) {
     let userFilesParam: string[] = [];
 
     // 从start节点获取USER_FILES参数值
-    const startNodeInfo = inputParamsComposable.getStartNodeInfo();
+    const startNodeInfo = props.startNodeData;
     if (startNodeInfo?.inputParams) {
       const userFilesParamConfig = startNodeInfo.inputParams.find((param: any) => param.code === 'USER_FILES');
       if (userFilesParamConfig?.value) {
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-input-params.ts b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-input-params.ts
index 70753f6b0ff925fdd2bd3774ea00ef017f1b5eb1..a93b67bd50ae66a110228b2e733e3809cfc159b5 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-input-params.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-input-params.ts
@@ -1,281 +1,167 @@
-import { ref, watch, onMounted } from 'vue';
+import { ref, onMounted } from 'vue';
 import { useVueFlow } from '@vue-flow/core';
 import type { InputParam, ParamType } from '../types';
+import {
+  nodeRegistry,
+  useTypeDetails,
+  type FlowNodeInstance,
+  type NodeData,
+  type TypeRefer,
+} from '@farris/flow-devkit';
+
+type TrialRunPanelTab = 'input' | 'result';
+
+interface ParamTypeInfo {
+  type: ParamType;
+  multiple: boolean;
+}
+
+/** 旧参数列表，用于保存用户输入的值 */
+let oldInputParams: InputParam[] = [];
 
 export function useInputParams() {
-  // 控制运行状态
+  /** 控制运行状态 */
   const isRunning = ref(false);
 
-  // 标签页状态
-  const activeTab = ref('input'); // input, result
+  /** 标签页状态 */
+  const activeTab = ref<TrialRunPanelTab>('input');
 
-  // 输入参数列表
+  /** 输入参数列表 */
   const inputParams = ref<InputParam[]>([]);
 
-  // 运行结果数据
+  /** 运行结果数据 */
   const runResult = ref('');
 
-  // 获取Vue Flow实例
   const { nodes: allNodes } = useVueFlow();
-
-  // 获取start节点信息
-  function getStartNodeInfo() {
-    // 使用Vue Flow的nodes响应式数据获取画布中的节点
-    const nodes = allNodes.value;
-    if (!nodes || nodes.length === 0) {
-      return null;
-    }
-
-    // 查找类型为'start'的节点
-    const startNode = nodes.find(node => node.data?.kind === 'start');
-    return startNode?.data || null; // 返回节点的data属性
+  const { isListType } = useTypeDetails();
+
+  function getStartNode(): FlowNodeInstance | undefined {
+    const startNode = allNodes.value.find(node => {
+      const nodeMeta = nodeRegistry.getNodeMetadata(node.type);
+      return nodeMeta?.isStartNode;
+    }) as any as FlowNodeInstance;
+    return startNode;
   }
 
-  // 检测参数配置变化（类型变化时清空对应参数值）
-  function checkAndClearModifiedParamValues(newStartNode: any, oldStartNode: any) {
-    if (!newStartNode?.inputParams || !oldStartNode?.inputParams) {
-      return;
-    }
-
-    const newParams = newStartNode.inputParams;
-    const oldParams = oldStartNode.inputParams;
-
-    // 创建参数映射，以参数名为键
-    const oldParamsMap = new Map();
-    oldParams.forEach((param: any) => {
-      if (param && param.code) {
-        oldParamsMap.set(param.code, param);
-      }
-    });
-
-    // 检查每个新参数的类型变化
-    newParams.forEach((newParam: any) => {
-      if (!newParam || !newParam.code) {
-        return;
-      }
-
-      const oldParam = oldParamsMap.get(newParam.code);
-      if (oldParam) {
-        // 检查参数类型是否变化
-        const oldTypeId = oldParam.type?.typeId || oldParam.type || 'string';
-        const newTypeId = newParam.type?.typeId || newParam.type || 'string';
-
-        if (oldTypeId !== newTypeId) {
-          // 参数类型变化，清空对应的输入参数值
-          const inputParamIndex = inputParams.value.findIndex(p => p.name === newParam.code);
-          if (inputParamIndex !== -1) {
-            // 根据新类型设置默认值
-            let defaultValue: any;
-            const newParamType = getParamTypeFromTypeId(newTypeId);
+  /** 获取开始节点数据 */
+  function getStartNodeInfo(): NodeData | undefined {
+    return getStartNode()?.data;
+  }
 
-            switch (newParamType) {
-              case 'boolean':
-                defaultValue = false;
-                break;
-              case 'object':
-              case 'array':
-                defaultValue = '';
-                break;
-              case 'fileID':
-                defaultValue = [];
-                break;
-              default:
-                defaultValue = null;
-            }
+  /** 开始节点的数据 */
+  const startNodeData = ref<NodeData | undefined>(getStartNodeInfo());
 
-            inputParams.value[inputParamIndex].value = defaultValue;
-          }
-        }
-      }
-    });
+  function getDefaultValueByParamType(paramType: ParamType): any {
+    switch (paramType) {
+      case 'boolean':
+        return false;
+      case 'object':
+      case 'array':
+        return '';
+      case 'fileID':
+        return [];
+      default:
+        return null;
+    }
   }
 
-  // 根据typeId获取参数类型
-  function getParamTypeFromTypeId(typeId: string): 'string' | 'number' | 'boolean' | 'fileID' | 'object' | 'array' {
+  function getParamTypeInfo(type?: TypeRefer): ParamTypeInfo {
+    const defaultResult: ParamTypeInfo = { type: 'string', multiple: false };
+    if (!type) {
+      return defaultResult;
+    }
+    if (isListType(type)) {
+      const listItemType = type.genericTypes?.[0];
+      if (listItemType && listItemType.typeId === 'fileID' && listItemType.source === 'default') {
+        return { type: 'fileID', multiple: true };
+      } else {
+        return { type: 'array', multiple: false };
+      }
+    }
+    if (type.source !== 'default') {
+      return defaultResult;
+    }
+    const typeId = type.typeId || 'string';
     switch (typeId) {
       case 'string':
-        return 'string';
+        return { type: 'string', multiple: false };
       case 'number':
       case 'int':
-        return 'number';
+        return { type: 'number', multiple: false };
       case 'boolean':
-        return 'boolean';
+        return { type: 'boolean', multiple: false };
       case 'fileID':
-        return 'fileID';
+        return { type: 'fileID', multiple: false };
       case 'any':
-        return 'object';
+        return { type: 'object', multiple: false };
       case 'array':
-        return 'array';
-      case 'list':
-        return 'array';
+        return { type: 'array', multiple: false };
       default:
-        return 'string';
+        return defaultResult;
     }
   }
 
-  // 监听画布节点数组的变化
-  watch(
-    allNodes,
-    (newNodes, oldNodes) => {
-      // 查找开始节点
-      const newStartNode = newNodes.find(node => node.data?.kind === 'start');
-      const oldStartNode = oldNodes?.find(node => node.data?.kind === 'start');
-
-      if (!newStartNode && !newNodes?.some(node => node.data?.inputParams)) {
+  // 获取所有需要用户输入的参数
+  function getAllRequiredInputParams(): Array<InputParam> {
+    const paramMap = new Map<string, InputParam>();
+
+    // 处理开始节点的参数
+    const startNode = getStartNode();
+    const startNodeParams = startNode?.data?.inputParams;
+    if (Array.isArray(startNodeParams) === false) {
+      return [];
+    }
+    startNodeParams.forEach((param) => {
+      if (!param || !param.code || !param.type) {
         return;
       }
-
-      // 检查start节点参数类型变化并清空对应值
-      if (oldStartNode && newStartNode) {
-        checkAndClearModifiedParamValues(newStartNode.data, oldStartNode.data);
+      // 排除`USER_INPUT`和`USER_FILES`参数，这些是绑定到用户输入的
+      if (param.code === 'USER_INPUT' || param.code === 'USER_FILES') {
+        return;
       }
-
-      // 获取所有需要输入的参数配置用于比较
-      const currentAllParams = getAllRequiredInputParams();
-      const currentParamsStr = JSON.stringify(currentAllParams.map(param => ({
-        name: param.name,
-        type: param.type,
-        required: param.required,
+      const { type: paramType, multiple } = getParamTypeInfo(param.type);
+
+      const paramInfo: InputParam = {
+        name: param.code,
+        label: (param.name || '').trim() || param.code,
+        type: paramType,
+        value: getDefaultValueByParamType(paramType),
+        required: param.required || false,
         description: param.description,
-        sourceNode: param.sourceNode
-      })));
-
-      const previousParamsStr = JSON.stringify(inputParams.value.map(param => ({
-        name: param.name,
-        type: param.type,
-        required: param.required,
-        description: param.description
-      })));
-
-      // 如果参数配置发生变化，重新初始化
-      if (currentParamsStr !== previousParamsStr) {
-        initializeInputParams();
-      }
-    },
-    {
-      deep: true, // 深度监听节点数组变化
-    }
-  );
-
-  // 获取所有需要用户输入的参数
-  function getAllRequiredInputParams(): Array<{ name: string, label: string, type: ParamType, value: any, required: boolean, description: string, sourceNode?: string, multiple?: boolean }> {
-    const requiredParams: Array<{ name: string, label: string, type: ParamType, value: any, required: boolean, description: string, sourceNode?: string, multiple?: boolean }> = [];
-
-    const nodes = allNodes.value;
-    if (!nodes || nodes.length === 0) {
-      return requiredParams;
-    }
-
-    // 用于去重的映射，key为参数名，value为参数信息
-    const paramMap = new Map<string, { name: string, label: string, type: ParamType, value: any, required: boolean, description: string, sourceNode?: string, multiple?: boolean }>();
-
-
-    // 处理start节点的参数
-    const startNode = nodes.find(node => node.data?.kind === 'start');
-    if (startNode?.data?.inputParams && Array.isArray(startNode.data.inputParams)) {
-      startNode.data.inputParams.forEach((param: any) => {
-        if (param && param.code && param.type) {
-          // 排除USER_INPUT和USER_FILES参数，这些是绑定到用户输入的
-          if (param.code === 'USER_INPUT' || param.code === 'USER_FILES') {
-            return;
-          }
+        multiple: multiple || false,
+        raw: param,
+      };
 
-          let paramType: ParamType = 'string';
-          const typeId = param.type.typeId || 'string';
-          let multiple = false;
-
-          // 根据typeId映射到输入类型
-          switch (typeId) {
-            case 'string': paramType = 'string'; break;
-            case 'number':
-            case 'int': paramType = 'number'; break;
-            case 'boolean': paramType = 'boolean'; break;
-            case 'fileID': paramType = 'fileID'; break;
-            case 'any': paramType = 'object'; break;
-            case 'array': paramType = 'array'; break;
-            case 'list':
-              if (param.type?.genericTypes?.length > 0 && param.type.genericTypes[0].typeId === 'fileID') {
-                paramType = 'fileID';
-                multiple = true;
-              } else {
-                paramType = 'array';
-              }
-              break;
-            default: paramType = 'string';
-          }
-
-          let defaultValue: any;
-          if (paramType === 'boolean') {
-            defaultValue = false;
-          } else if (paramType === 'object' || paramType === 'array') {
-            defaultValue = '';
-          } else if (paramType === 'fileID') {
-            defaultValue = [];
-          } else {
-            defaultValue = null;
-          }
-
-          const paramInfo = {
-            name: param.code,
-            label: param.description || param.code,
-            type: paramType,
-            value: defaultValue,
-            required: param.required || false,
-            description: param.description,
-            sourceNode: 'start',
-            multiple: multiple || false,
-          };
+      // 根据参数名去重
+      paramMap.set(param.code, paramInfo);
+    });
 
-          // 使用参数名作为key进行去重
-          paramMap.set(param.code, paramInfo);
-        }
-      });
-    }
+    return Array.from(paramMap.values());
+  }
 
-    // 将map转换为数组
-    const result = Array.from(paramMap.values());
-    return result.map(item => ({
-      ...item,
-      type: item.type as ParamType,
-      multiple: item.multiple || false,
-    }));
+  function isSameParamType(paramA: InputParam, paramB: InputParam): boolean {
+    return !!paramA && !!paramB && paramA.type === paramB.type && paramA.multiple === paramB.multiple;
   }
 
-  // 初始化输入参数，从start节点读取inputParams
   function initializeInputParams() {
     const allRequiredParams = getAllRequiredInputParams();
-
-    // 保存当前已输入的值（如果参数名匹配）
-    const existingValues = new Map();
-    inputParams.value.forEach(param => {
-      existingValues.set(param.name, param.value);
+    const paramName2OldParam = new Map<string, InputParam>();
+    oldInputParams.forEach(param => {
+      paramName2OldParam.set(param.name, param);
     });
-
-    // 清空现有参数
-    inputParams.value = [];
-
-    // 重新创建参数列表
-    allRequiredParams.forEach((param) => {
-      // 优先使用之前输入的值，如果没有则使用默认值
-      let defaultValue = existingValues.get(param.name);
-      if (defaultValue === undefined) {
-        defaultValue = param.value;
+    allRequiredParams.forEach(param => {
+      const oldParam = paramName2OldParam.get(param.name);
+      if (oldParam && isSameParamType(oldParam, param)) {
+        param.value = oldParam.value;
       }
-
-      inputParams.value.push({
-        name: param.name,
-        label: param.label,
-        type: param.type,
-        value: defaultValue,
-        required: param.required,
-        description: param.description,
-        multiple: param.multiple || false,
-      });
     });
+    inputParams.value = allRequiredParams;
+    oldInputParams = allRequiredParams;
   }
 
   // 组件挂载时初始化数据
   onMounted(() => {
+    startNodeData.value = getStartNodeInfo();
     initializeInputParams();
   });
 
@@ -328,14 +214,19 @@ export function useInputParams() {
     });
   }
 
+  function setActiveTab(tab: TrialRunPanelTab) {
+    activeTab.value = tab;
+  }
+
   return {
     isRunning,
     activeTab,
     runResult,
     inputParams,
+    startNodeData,
     getStartNodeInfo,
     updateParamValue,
     checkRequiredParams,
-    setActiveTab: (tab: string) => { activeTab.value = tab; }
+    setActiveTab,
   };
-}
\ No newline at end of file
+}
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-trial-run.ts b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-trial-run.ts
index aae24f36cccc41016c183c8364cf1796275b86fa..913ae3c9e455eeeec77ec823571f162eba12b160 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-trial-run.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/composables/use-trial-run.ts
@@ -10,9 +10,10 @@ export function useTrialRun() {
     activeTab,
     runResult,
     inputParams,
+    startNodeData,
     updateParamValue,
     checkRequiredParams,
-    setActiveTab
+    setActiveTab,
   } = useInputParams();
 
   const notifyService = useNotify();
@@ -83,6 +84,7 @@ export function useTrialRun() {
     activeTab,
     runResult,
     inputParams,
+    startNodeData,
 
     // 方法
     updateParamValue,
@@ -91,6 +93,6 @@ export function useTrialRun() {
     setActiveTab,
 
     // 工具方法
-    checkRequiredParams
+    checkRequiredParams,
   };
 }
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/param-input.vue b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/param-input.vue
index 42669711ddcc0ad84cb2d232376e1f71dc929356..4122e972ae1128b87f8c29161921ca80814d0027 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/param-input.vue
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/param-input.vue
@@ -1,19 +1,32 @@
 <template>
   <div class="param-item">
-    <label class="param-label">
-      {{ param.label }}
+    <label :class="['param-label', paramDescription && 'param-label--desc']">
       <span v-if="param.required" class="required-mark">*</span>
-      <span class="param-type">{{ param.type.toUpperCase() }}</span>
+      <span class="param-name" :title="paramName">{{ paramName }}</span>
+      <span class="param-type" :title="paramTypeName">{{ paramTypeCode }}</span>
     </label>
 
-    <!-- 字符串输入 -->
+    <div class="param-desc" v-if="paramDescription" :title="paramDescription">{{ paramDescription }}</div>
+
+    <!-- 字符串输入/文本框 -->
     <input
-      v-if="param.type === 'string'"
+      v-if="param.type === 'string' && selectOptions.length === 0"
       :value="param.value"
       @input="updateValue(($event.target as HTMLInputElement).value)"
       type="text"
       class="string-input"
-      :placeholder="`请输入${param.label}`"
+      :placeholder="`请输入${paramName}`"
+    />
+
+    <!-- 字符串输入/下拉列表 -->
+    <TSelect
+      v-else-if="param.type === 'string' && selectOptions.length > 0"
+      class="fvf-trial-param-select"
+      :value="param.value"
+      :options="selectOptions"
+      :clearable="true"
+      size="medium"
+      @change="updateValue"
     />
 
     <!-- 数字输入 -->
@@ -23,7 +36,7 @@
       @input="updateValue(Number(($event.target as HTMLInputElement).value))"
       type="number"
       class="number-input"
-      :placeholder="`请输入${param.label}`"
+      :placeholder="`请输入${paramName}`"
     />
 
     <!-- 布尔值输入 -->
@@ -72,6 +85,16 @@
 import type { InputParam } from './types';
 import FileUpload from './file-upload.vue';
 import JsonEditor from './json-editor.vue';
+import {
+  useTypeDetails,
+  TSelect,
+  ParameterUtils,
+  BasicTypeRefer,
+  InputHelpKind,
+  type EnumInputHelp,
+  type TdOptionProps,
+  type TypeRefer,
+} from '@farris/flow-devkit';
 import { computed } from 'vue';
 
 interface Props {
@@ -83,10 +106,63 @@ interface Emits {
   (e: 'update', index: number, value: any): void;
 }
 
+const {
+  getTypeCode,
+  getTypeName,
+} = useTypeDetails();
+
 const props = defineProps<Props>();
 const emit = defineEmits<Emits>();
-console.log('param', props.param);
-// const isFileID = computed(() => props.param.type === 'fileID' || (props.param.type === 'array' && props.param.type === 'fileID'));
+
+const paramTypeRefer = computed<TypeRefer | undefined>(() => props.param?.raw?.type);
+const defaultTypeCode = computed<string>(() => props.param.type.toUpperCase());
+
+const paramTypeCode = computed<string>(() => {
+  if (paramTypeRefer.value) {
+    return getTypeCode(paramTypeRefer.value);
+  }
+  return defaultTypeCode.value;
+});
+
+const paramTypeName = computed<string>(() => {
+  if (paramTypeRefer.value) {
+    return getTypeName(paramTypeRefer.value);
+  }
+  return defaultTypeCode.value;
+});
+
+const paramName = computed<string>(() => {
+  const param = props.param;
+  const rawParam = param.raw;
+  const displayName = (rawParam?.name || '').trim();
+  if (displayName) {
+    return displayName;
+  }
+  return rawParam?.code || param.label;
+});
+
+const paramDescription = computed<string>(() => {
+  return (props.param?.raw?.description || '').trim();
+});
+
+const selectOptions = computed<TdOptionProps[]>(() => {
+  const param = props.param.raw;
+  const type = param?.type;
+  if (!ParameterUtils.isSame(type, BasicTypeRefer.StringType) || !param) {
+    return [];
+  }
+  const inputHelp = param.inputHelp as (EnumInputHelp | undefined);
+  if (inputHelp?.kind !== InputHelpKind.enum) {
+    return [];
+  }
+  const enumItems = inputHelp.items || [];
+  return enumItems.map((item) => {
+    if (!item) {
+      return;
+    }
+    return { label: item.key, value: item.value };
+  }).filter(item => !!item);
+});
 
 function updateValue(value: any) {
   emit('update', props.index, value);
@@ -104,7 +180,7 @@ function updateValue(value: any) {
 
     .required-mark {
       color: #ff4d4f;
-      margin-left: 2px;
+      margin-right: 2px;
     }
 
     .param-type {
@@ -116,6 +192,27 @@ function updateValue(value: any) {
       margin-left: 8px;
       font-weight: 400;
     }
+
+    .param-name {
+      font-weight: 600;
+      color: rgb(53, 64, 82);
+    }
+
+    &--desc {
+      margin-bottom: 4px;
+    }
+  }
+
+  .param-desc {
+    color: rgba(32, 41, 69, 0.62);
+    font-weight: 400;
+    font-size: 12px;
+    line-height: 16px;
+    margin-bottom: 6px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    cursor: default;
   }
 
   .string-input,
@@ -171,4 +268,16 @@ function updateValue(value: any) {
     }
   }
 }
-</style>
\ No newline at end of file
+
+.fvf-trial-param-select {
+  :deep(.t-input) {
+    border-color: #d9d9d9;
+    height: 34px;
+
+    &.t-input--focused {
+      border-color: #5b89fe;
+      box-shadow: 0 0 0 2px rgba(91, 137, 254, 0.1);
+    }
+  }
+}
+</style>
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/trial-run.vue b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/trial-run.vue
index c51c2960b5f5bca3a408b2259239d570530dd97b..feba1b58c4272982ebc501d83ccf41a6c354ed00 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/trial-run.vue
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/trial-run.vue
@@ -21,6 +21,7 @@ const {
   activeTab,
   runResult,
   inputParams,
+  startNodeData,
   updateParamValue,
   runWorkflow,
 } = useTrialRun();
@@ -63,7 +64,7 @@ defineEmits<{
 
     <!-- 对话流调试模式 -->
     <div v-if="isChatFlow && debugMode === 'chat'" class="chat-debug-mode">
-      <chat-debug :input-params="inputParams" />
+      <chat-debug :input-params="inputParams" :start-node-data="startNodeData" />
     </div>
 
     <!-- 参数调试模式（传统试运行） -->
@@ -234,7 +235,7 @@ defineEmits<{
     overflow: visible;
 
     .tab-item {
-      padding: 0 14px 7px 14px;
+      padding: 4px 14px 3px 14px;
       cursor: pointer;
       font-size: 14px;
       font-weight: 400;
diff --git a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/types.ts b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/types.ts
index a43deec073690a0f33b7c0a3ac6d4b0864850f65..a4a2bfd35b832129139fccef393214375a9de635 100644
--- a/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/types.ts
+++ b/ai-flow-front/packages/flow-designer/src/components/toolbar/components/trial-run/types.ts
@@ -1,3 +1,5 @@
+import type { Parameter } from '@farris/flow-devkit';
+
 // 参数输入类型
 export type ParamType = 'string' | 'number' | 'boolean' | 'fileID' | 'object' | 'array';
 
@@ -10,7 +12,10 @@ export interface InputParam {
   required?: boolean;
   description?: string;
   jsonError?: string;
-  multiple?: boolean; // 是否支持多文件
+  /** 是否支持多文件 */
+  multiple?: boolean;
+  /** 原始参数 */
+  raw?: Parameter;
 }
 
 // 文件信息
diff --git a/ai-flow-front/packages/flow-designer/src/hooks/node.utils.ts b/ai-flow-front/packages/flow-designer/src/hooks/node.utils.ts
index 7108ebaf115b90230c1a75c62dfc83f1cc61c0e4..b493d465048070325621b7ae02ec7d2f6856b53d 100644
--- a/ai-flow-front/packages/flow-designer/src/hooks/node.utils.ts
+++ b/ai-flow-front/packages/flow-designer/src/hooks/node.utils.ts
@@ -1,6 +1,6 @@
 import type { Node } from '@vue-flow/core';
 import type { Parameter, NodeDefinition, NodeMetadata, NodeData } from '@farris/flow-devkit';
-import { nodeRegistry } from '@farris/flow-devkit';
+import { nodeRegistry, uuid } from '@farris/flow-devkit';
 
 export class NodeUtils {
 
@@ -25,7 +25,18 @@ export class NodeUtils {
         return !!nodeMeta?.isStartNode;
     }
 
-    public static getOutputParams(node: Node): Parameter[] {
+    private static visitParameter(collection: Parameter[], visitedParamIdSet: Set<string>, parameter: Parameter): void {
+        if (!parameter.id) {
+            parameter.id = uuid();
+        }
+        if (visitedParamIdSet.has(parameter.id)) {
+            return;
+        }
+        collection.push(parameter);
+        visitedParamIdSet.add(parameter.id);
+    }
+
+    private static getOutputParamsByDefault(node: Node): Parameter[] {
         const isStartNode = this.isStartNode(node);
         const nodeData = (node.data || {}) as NodeData;
         if (isStartNode) {
@@ -37,4 +48,20 @@ export class NodeUtils {
         return nodeData.outputParams || [];
     }
 
+    public static getAllOutputParams(node: Node): Parameter[] {
+        const visitedParamIdSet = new Set<string>();
+        const allParams: Parameter[] = [];
+        const nodeData = (node.data || {}) as NodeData;
+        const nodeDef = this.getNodeDefinition(node.type!);
+        const outputParams = typeof nodeDef?.getOutputParams === 'function'
+            ? nodeDef.getOutputParams(nodeData)
+            : this.getOutputParamsByDefault(node);
+        outputParams.forEach(param => this.visitParameter(allParams, visitedParamIdSet, param));
+        if (typeof nodeDef?.getOutputParamsForChildNodes === 'function') {
+            const outputParamsForChildNodes = nodeDef.getOutputParamsForChildNodes(nodeData);
+            outputParamsForChildNodes.forEach(param => this.visitParameter(allParams, visitedParamIdSet, param));
+        }
+        return allParams;
+    }
+
 }
diff --git a/ai-flow-front/packages/flow-designer/src/hooks/use-edge-types.ts b/ai-flow-front/packages/flow-designer/src/hooks/use-edge-types.ts
index c37510268628510a0bcd2b93937e06c2878313cd..bab208ddfce93ba420ee1fc311014c2c58904e23 100644
--- a/ai-flow-front/packages/flow-designer/src/hooks/use-edge-types.ts
+++ b/ai-flow-front/packages/flow-designer/src/hooks/use-edge-types.ts
@@ -3,7 +3,7 @@ import { type EdgeProps } from '@vue-flow/core';
 import { CommonEdge } from '@farris/flow-devkit';
 
 const edgeTypes = reactive<Record<string, Component<EdgeProps>>>({
-    common: markRaw(CommonEdge),
+    common: markRaw(CommonEdge as any),
 });
 
 export function useEdgeTypes() {
diff --git a/ai-flow-front/packages/flow-designer/src/hooks/use-flow-metadata-from-backend.ts b/ai-flow-front/packages/flow-designer/src/hooks/use-flow-metadata-from-backend.ts
index 16284efbd76960f51bd0029473180e1075b48a00..c7cc230515f718af483ec8337fe9d1c339f14d75 100644
--- a/ai-flow-front/packages/flow-designer/src/hooks/use-flow-metadata-from-backend.ts
+++ b/ai-flow-front/packages/flow-designer/src/hooks/use-flow-metadata-from-backend.ts
@@ -93,7 +93,14 @@ export function useFlowMetadataFromBackend(flowDesignerProps?: FlowDesignerProps
             console.error(errorTip);
             return false;
         }
-        const data = JSON.parse(JSON.stringify(newFlowMetadata));
+        let data = JSON.parse(JSON.stringify(newFlowMetadata));
+        const beforeSaveMetadata = flowRegistry.value?.beforeSaveMetadata;
+        if (typeof beforeSaveMetadata === 'function') {
+            data = beforeSaveMetadata(data);
+            if (!data) {
+                return false;
+            }
+        }
         const result = await FlowApi.saveFlowMetadata(data);
         const isSuccess = result?.success ?? false;
         if (!silent) {
diff --git a/ai-flow-front/packages/flow-designer/src/hooks/use-vue-flow-data-converter.ts b/ai-flow-front/packages/flow-designer/src/hooks/use-vue-flow-data-converter.ts
index 4d020ae5ed56f3589ab2125c417424fadd88f2eb..930ddd387dfdf82d3ae7446545a649c3601148cd 100644
--- a/ai-flow-front/packages/flow-designer/src/hooks/use-vue-flow-data-converter.ts
+++ b/ai-flow-front/packages/flow-designer/src/hooks/use-vue-flow-data-converter.ts
@@ -6,10 +6,12 @@ import type {
     Parameter,
     NodeVariableExpr,
     EdgeGraphMeta,
+    JsonSchema,
 } from '@farris/flow-devkit';
 import {
     uuid,
     nodeRegistry,
+    JsonSchemaUtils,
     NODE_OUTPUT_PARAMS_KEY,
     NODE_OUTPUT_PARAMS_FOR_CHILD_NODES_KEY,
     NODE_VALIDATION_DETAILS_KEY,
@@ -73,6 +75,21 @@ export function useVueFlowDataConverter() {
         recurse(data);
     }
 
+    function ensureJsonSchemaHaveId(schema?: JsonSchema): void {
+        if (!schema) {
+            return;
+        }
+        if (!schema.id) {
+            schema.id = uuid();
+        }
+        if (schema.items) {
+            ensureJsonSchemaHaveId(schema.items);
+        }
+        if (Array.isArray(schema.properties)) {
+            schema.properties.forEach(property => ensureJsonSchemaHaveId(property));
+        }
+    }
+
     /**
      * 保证参数具有唯一ID
      * @description 后端仅存储参数的编号，不存储id，由于编号可编辑不方便作为标识，所以前端额外维护id字段
@@ -80,7 +97,10 @@ export function useVueFlowDataConverter() {
      */
     function ensureAllParamsHaveIds(params: Parameter[]): void {
         params.forEach(param => {
-            param.id = uuid();
+            if (!param.id) {
+                param.id = uuid();
+            }
+            ensureJsonSchemaHaveId(param.schema);
         });
     }
 
@@ -93,7 +113,8 @@ export function useVueFlowDataConverter() {
                 return;
             }
             const paramCode2Param = new Map<string, Parameter>();
-            const outputParams = NodeUtils.getOutputParams(node);
+            const outputParams = NodeUtils.getAllOutputParams(node);
+            ensureAllParamsHaveIds(outputParams);
             outputParams.forEach(param => {
                 const paramCode = useParamId ? param.id : param.code;
                 if (!paramCode) {
@@ -106,6 +127,34 @@ export function useVueFlowDataConverter() {
         return resultMap;
     }
 
+    function syncParamId(valueExpr: NodeVariableExpr, param?: Parameter): void {
+        if (!valueExpr || !param) {
+            return;
+        }
+        valueExpr.variableId = param.id;
+        if (valueExpr.fields && valueExpr.fields.length) {
+            valueExpr.fieldIds = JsonSchemaUtils.getIdPathByCodePath(param.schema, valueExpr.fields);
+            if (!valueExpr.fieldIds.length) {
+                valueExpr.fieldIds = undefined;
+            }
+        } else {
+            valueExpr.fieldIds = undefined;
+        }
+    }
+
+    function syncParamCodeById(valueExpr: NodeVariableExpr, param?: Parameter): void {
+        if (!valueExpr || !param) {
+            return;
+        }
+        valueExpr.variable = param.code || '';
+        if (valueExpr.fieldIds && valueExpr.fieldIds.length) {
+            const codes = JsonSchemaUtils.getCodePathByIdPath(param.schema, valueExpr.fieldIds);
+            if (codes.length) {
+                valueExpr.fields = codes;
+            }
+        }
+    }
+
     function validAllNodeParams(nodes: Node[]): void {
         nodes.forEach(node => {
             const nodeData: NodeData = node.data;
@@ -119,9 +168,7 @@ export function useVueFlowDataConverter() {
                 return;
             }
             const param = paramCode2Param.get(valueExpr.variable);
-            if (param) {
-                valueExpr.variableId = param.id;
-            }
+            syncParamId(valueExpr, param);
         };
         nodes.forEach(node => {
             processAllNodeVariableExpr(node.data, handleNodeVariableExpr);
@@ -136,9 +183,7 @@ export function useVueFlowDataConverter() {
                 return;
             }
             const param = paramId2Param.get(valueExpr.variableId);
-            if (param && param.code) {
-                valueExpr.variable = param.code;
-            }
+            syncParamCodeById(valueExpr, param);
         };
         nodes.forEach(node => {
             processAllNodeVariableExpr(node.data, handleNodeVariableExpr);
diff --git a/ai-flow-front/packages/flow-devkit/lib/components/common-edge.vue b/ai-flow-front/packages/flow-devkit/lib/components/common-edge.vue
index b7807bea9dc3d246ea1207468a70adb27649660b..f530f64d3a3aa9f6764eabef7f88f81b3eb2e265 100644
--- a/ai-flow-front/packages/flow-devkit/lib/components/common-edge.vue
+++ b/ai-flow-front/packages/flow-devkit/lib/components/common-edge.vue
@@ -14,7 +14,7 @@ import { computed } from 'vue';
 import { BaseEdge, getBezierPath, type EdgeProps } from '@vue-flow/core';
 import CommonMarker from './common-marker.vue';
 
-const props = defineProps<EdgeProps>();
+const props = defineProps<Partial<EdgeProps>>();
 const path = computed(() => getBezierPath(props as any));
 
 const markerId = computed(() => `${props.id}-marker`);
diff --git a/ai-flow-front/packages/flow-devkit/lib/composition/use-type-details.ts b/ai-flow-front/packages/flow-devkit/lib/composition/use-type-details.ts
index 8157ae043d4b9d9f62d7401057c470a4a5104f2f..47c824403f096fadec7334ff50891d782885d0c7 100644
--- a/ai-flow-front/packages/flow-devkit/lib/composition/use-type-details.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/composition/use-type-details.ts
@@ -123,11 +123,27 @@ export function useTypeDetails() {
         return isArray(typeRefer) || isCollection(typeRefer) || isIterable(typeRefer);
     }
 
+    /**
+     * 计算列表的层数
+     * @description 如果是二维列表则返回`2`，如果是三维列表则返回`3`，计算到第一个非列表元素为止
+     * @param typeRefer 类型
+     * @returns 列表的层数
+     */
+    function getListDepth(typeRefer?: TypeRefer, count = 0): number {
+        if (!typeRefer || !isListType(typeRefer)) {
+            return count;
+        }
+        return getListDepth(typeRefer.genericTypes?.[0], count + 1);
+    }
+
     function getListItemType(typeRefer?: TypeRefer): Type | undefined {
         const itemTypeRefer = typeRefer?.genericTypes?.[0];
         if (!itemTypeRefer) {
             return undefined;
         }
+        if (isListType(itemTypeRefer)) {
+            return getListItemType(itemTypeRefer);
+        }
         return fullTypeID2Type.get(getFullTypeID(itemTypeRefer));
     }
 
@@ -209,6 +225,21 @@ export function useTypeDetails() {
         return _getTypeName(typeRefer);
     }
 
+    function wrapTypeWithArray(itemType: TypeRefer, count: number): TypeRefer {
+        let wrappedType = itemType;
+        while (count > 0) {
+            --count;
+            wrappedType = {
+                source: 'default',
+                typeId: 'list',
+                typeCode: `Array<${wrappedType.typeCode || wrappedType.typeId}>`,
+                typeName: `Array<${wrappedType.typeName || wrappedType.typeCode || wrappedType.typeId}>`,
+                genericTypes: [wrappedType],
+            };
+        }
+        return wrappedType;
+    }
+
     function hasNestedFieldPath(typeRefer?: TypeRefer, fields?: string[]): boolean {
         if (!fields || !fields.length) {
             return true;
@@ -235,6 +266,31 @@ export function useTypeDetails() {
             : true;
     }
 
+    function getFieldTypeRefer(typeRefer?: TypeRefer, fields?: string[], listDepth = 0): TypeRefer | undefined {
+        if (!typeRefer) {
+            return undefined;
+        }
+        if (!fields || !fields.length) {
+            return wrapTypeWithArray(typeRefer, listDepth);
+        }
+        const currentType = isListType(typeRefer)
+            ? getListItemType(typeRefer)
+            : fullTypeID2Type.get(getFullTypeID(typeRefer));
+        if (!currentType) {
+            return undefined;
+        }
+        const listDepthAdder = getListDepth(typeRefer);
+        const currentFieldName = fields[0];
+        const remainingFields = fields.slice(1);
+        const matchedField = currentType.fields?.find(
+            (field) => field.code === currentFieldName
+        );
+        if (!matchedField) {
+            return undefined;
+        }
+        return getFieldTypeRefer(matchedField.type, remainingFields, listDepth + listDepthAdder);
+    }
+
     return {
         fullTypeID2Type,
         getFullTypeID,
@@ -248,8 +304,11 @@ export function useTypeDetails() {
         isCollection,
         isIterable,
         isListType,
+        getListDepth,
         getListItemType,
         getListItemTypeRefer,
         hasNestedFieldPath,
+        wrapTypeWithArray,
+        getFieldTypeRefer,
     };
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b7fe76071a7a61c48ac5a38ee08c6c1064031679
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/index.ts
@@ -0,0 +1,7 @@
+import BasicTypeSelectorInstallless from './src/basic-type-selector.component';
+import { withInstall } from '@farris/flow-devkit/types';
+
+const BasicTypeSelector = withInstall(BasicTypeSelectorInstallless);
+
+export { BasicTypeSelector };
+export default BasicTypeSelector;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.component.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..926c0ca978452f3efd468caf1d125da072b9fc1f
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.component.tsx
@@ -0,0 +1,56 @@
+import { computed, defineComponent } from 'vue';
+import { basicTypeSelectorProps, BASIC_TYPE_SELECTOR_NAME } from './basic-type-selector.props';
+import { TSelect, type TdOptionProps } from '@farris/flow-devkit/third-party';
+
+import './basic-type-selector.scss';
+
+export default defineComponent({
+  name: BASIC_TYPE_SELECTOR_NAME,
+  props: basicTypeSelectorProps,
+  emits: {
+    'update:modelValue': (_newType: string) => {
+      return true;
+    },
+  },
+  setup(props, context) {
+    const shouldShowArrow = computed<boolean>(() => !props.readonly);
+
+    const selectOptions = computed<TdOptionProps[]>(() => [
+      { value: 'string', label: 'String' },
+      { value: 'number', label: 'Number' },
+      { value: 'boolean', label: 'Boolean' },
+      { value: 'object', label: 'Object', disabled: props.disableObjectOptions },
+      { value: 'array-string', label: 'Array<String>' },
+      { value: 'array-number', label: 'Array<Number>' },
+      { value: 'array-boolean', label: 'Array<Boolean>' },
+      { value: 'array-object', label: 'Array<Object>', disabled: props.disableObjectOptions },
+    ]);
+
+    const currentLabel = computed<string>(() => {
+      const option = selectOptions.value.find(item => item.value === props.modelValue);
+      return option?.label || '';
+    });
+
+    function onChange(newValue: any): void {
+      context.emit('update:modelValue', newValue);
+    }
+
+    return () => (
+      <TSelect
+        value={props.modelValue}
+        options={selectOptions.value}
+        clearable={false}
+        size={'small'}
+        readonly={props.readonly}
+        showArrow={shouldShowArrow.value}
+        popupProps={{
+          overlayInnerClassName: 'larger-max-height',
+        }}
+        {...{
+          title: currentLabel.value,
+        }}
+        onChange={onChange}
+      ></TSelect>
+    );
+  },
+});
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.props.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.props.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0babef8340961cf7b7f01e1f72eb6be8fe1ca776
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.props.ts
@@ -0,0 +1,14 @@
+import type { ExtractPropTypes } from 'vue';
+
+export const BASIC_TYPE_SELECTOR_NAME = 'FvfBasicTypeSelector';
+
+export const basicTypeSelectorProps = {
+    /** 绑定值 */
+    modelValue: { type: String },
+    /** 是否只读 */
+    readonly: { type: Boolean, default: false },
+    /** 禁用`Object`相关的选项 */
+    disableObjectOptions: { type: Boolean, default: false },
+};
+
+export type BasicTypeSelectorProps = ExtractPropTypes<typeof basicTypeSelectorProps>;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.scss
new file mode 100644
index 0000000000000000000000000000000000000000..f77dce279217cd6c2cbd351d60f40fe1f9fcf0af
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/basic-type-selector/src/basic-type-selector.scss
@@ -0,0 +1,7 @@
+.fvf-basic-type-selector {
+    &__current-value {
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5446f111ed01164bd91d5cf7f28ae8b98dd36fd8
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/index.ts
@@ -0,0 +1,7 @@
+import EnumInputHelpInstallless from './src/enum-input-help.component';
+import { withInstall } from '@farris/flow-devkit/types';
+
+const EnumInputHelpEditor = withInstall(EnumInputHelpInstallless);
+
+export { EnumInputHelpEditor };
+export default EnumInputHelpEditor;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.component.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..4d9101d70572a8619bad3e564c1c0964b5cd880c
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.component.tsx
@@ -0,0 +1,164 @@
+import { computed, defineComponent, ref, onMounted } from 'vue';
+import { enumInputHelpProps } from './enum-input-help.props';
+import { useBem, uuid, InputHelpUtils } from '@farris/flow-devkit/utils';
+import type { EnumInputHelp, EnumItem } from '@farris/flow-devkit/types';
+import Sortable, { type SortableEvent } from 'sortablejs';
+
+import './enum-input-help.scss';
+
+const name = 'FvfEnumInputHelp';
+
+export default defineComponent({
+  name,
+  props: enumInputHelpProps,
+  emits: {
+    'update:modelValue': (_newValue: EnumInputHelp) => {
+      return true;
+    },
+  },
+  setup(props, context) {
+    const { bem } = useBem(name);
+
+    const listRef = ref<HTMLDivElement>();
+
+    const items = computed<EnumItem[]>(() => {
+      const value = props.modelValue?.items;
+      return Array.isArray(value) ? value : [];
+    });
+
+    const hoveredItemId = ref<string>('');
+    const focusedItemId = ref<string>('');
+
+    function handleDeleteMouseEnter(enumItem: EnumItem): void {
+      if (enumItem?.id) {
+        hoveredItemId.value = enumItem.id;
+      }
+    }
+
+    function handleDeleteMouseLeave(): void {
+      hoveredItemId.value = '';
+    }
+
+    function handleItemFocus(enumItem: EnumItem): void {
+      focusedItemId.value = '';
+      if (enumItem?.id) {
+        focusedItemId.value = enumItem.id;
+      }
+    }
+
+    function handleItemBlur(enumItem: EnumItem): void {
+      if (enumItem?.id === focusedItemId.value) {
+        focusedItemId.value = '';
+      }
+    }
+
+    function emitChange(newItems: EnumItem[]): void {
+      const newValue = InputHelpUtils.createEnumInputHelp(newItems);
+      context.emit('update:modelValue', newValue);
+    }
+
+    function handleAdd(): void {
+      const newItem: EnumItem = { key: '', value: '', id: uuid() };
+      const newItems = [...items.value, newItem];
+      emitChange(newItems);
+    }
+
+    function handleDelete(index: number): void {
+      const newItems = [...items.value];
+      newItems.splice(index, 1);
+      emitChange(newItems);
+    }
+
+    function handleDragEnd(event: SortableEvent): void {
+      const { oldIndex, newIndex } = event;
+      if (oldIndex === newIndex || typeof oldIndex !== 'number' || typeof newIndex !== 'number') {
+        return;
+      }
+      const newItems = [...items.value];
+      const [movedItem] = newItems.splice(oldIndex, 1);
+      newItems.splice(newIndex, 0, movedItem);
+      emitChange(newItems);
+    }
+
+    onMounted(() => {
+      if (listRef.value) {
+        new Sortable(listRef.value, {
+          handle: `.${bem('item-handle')}`,
+          animation: 150,
+          onEnd: handleDragEnd,
+        });
+      }
+    });
+
+    function renderEnumItem(enumItem: EnumItem, index: number) {
+      if (!enumItem.id) {
+        enumItem.id = uuid();
+      }
+      return (
+        <div class={{
+          [bem('item')]: true,
+          [bem('item', 'danger')]: enumItem.id === hoveredItemId.value,
+          [bem('item', 'focus')]: enumItem.id === focusedItemId.value,
+        }} key={enumItem.id} title={enumItem.value || ''}>
+          <div class={['f-icon f-icon-drag-vertical', bem('item-handle')]} title=""></div>
+          <input
+            class={bem('item-input')}
+            type="text"
+            value={enumItem.value}
+            title={enumItem.value || ''}
+            placeholder="选项值"
+            onInput={(event) => {
+              const inputValue = (event.target as HTMLInputElement).value;
+              if (enumItem.key === enumItem.value) {
+                enumItem.key = inputValue;
+              }
+              enumItem.value = inputValue;
+            }}
+            onFocus={() => handleItemFocus(enumItem)}
+            onBlur={() => handleItemBlur(enumItem)}
+          />
+          <input
+            class={bem('item-input')}
+            type="text"
+            value={enumItem.key}
+            title={enumItem.key || ''}
+            placeholder="选项名称"
+            onInput={(event) => {
+              const inputValue = (event.target as HTMLInputElement).value;
+              enumItem.key = inputValue;
+            }}
+            onFocus={() => handleItemFocus(enumItem)}
+            onBlur={() => handleItemBlur(enumItem)}
+          />
+          <div
+            class={bem('item-delete')}
+            title="删除选项"
+            onClick={() => handleDelete(index)}
+            onMouseenter={() => handleDeleteMouseEnter(enumItem)}
+            onMouseleave={handleDeleteMouseLeave}
+          >
+            <i class="f-icon f-icon-enclosure_delete" />
+          </div>
+        </div>
+      );
+    }
+
+    function renderAddButton() {
+      return (
+        <div class={bem('add')} title="添加选项" onClick={handleAdd}>
+          <i class="f-icon f-icon-add" />
+          <span>添加选项</span>
+        </div>
+      );
+    }
+
+    return () => (
+      <div class={bem()}>
+        <div class={bem('list')} ref={listRef}>
+          {items.value.map((item, index) => renderEnumItem(item, index))}
+        </div>
+        {renderAddButton()}
+      </div>
+    );
+  },
+});
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.props.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.props.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fa351cb81770c6a49275fe84af19451537d7f596
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.props.ts
@@ -0,0 +1,9 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { EnumInputHelp } from '@farris/flow-devkit/types';
+
+export const enumInputHelpProps = {
+    /** `下拉选项`输入帮助 */
+    modelValue: { type: Object as PropType<EnumInputHelp> },
+};
+
+export type EnumInputHelpProps = ExtractPropTypes<typeof enumInputHelpProps>;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.scss
new file mode 100644
index 0000000000000000000000000000000000000000..578b6b20719e8f2dda35070fb2c9f23fb342e3f8
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/enum-input-help/src/enum-input-help.scss
@@ -0,0 +1,108 @@
+.fvf-enum-input-help {
+    display: block;
+
+    &__add {
+        display: flex;
+        align-items: center;
+        cursor: pointer;
+        user-select: none;
+        gap: 6px;
+        padding: 0 12px;
+        border-radius: 8px;
+        height: 26px;
+        font-size: 12px;
+        border: 1px solid #e8ebf2;
+        color: #354052;
+        background-color: #ffffff;
+        margin-top: 4px;
+
+        .f-icon {
+            font-size: 14px;
+        }
+
+        &:hover {
+            color: #2a87ff;
+            border-color: #529dff;
+        }
+        &:active {
+            color: #0e6ded;
+            border-color: #0e6ded;
+        }
+    }
+
+    &__item {
+        display: flex;
+        align-items: center;
+        background-color: #ffffff;
+        border: 1px solid rgba(16, 24, 40, 0.08);
+        border-radius: 8px;
+
+        &-handle {
+            flex: 0 0 auto;
+            min-width: 0;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding-left: 7px;
+            padding-right: 3px;
+            width: 26px !important;
+            height: 100% !important;
+            font-size: 16px !important;
+            cursor: grab;
+            user-select: none;
+        }
+
+        &-input {
+            flex: 1 1 0;
+            min-width: 0;
+            color: #354052;
+            line-height: 26px;
+            height: 26px;
+            font-size: 12px;
+            padding-left: 6px;
+            border: none;
+            outline: none;
+            background-color: transparent;
+            border-left: 1px solid;
+            border-right: 1px solid;
+            border-color: rgba(16, 24, 40, 0.16);
+        }
+
+        &-input + &-input {
+            border-left: none;
+        }
+
+        &-delete {
+            flex: 0 0 auto;
+            min-width: 0;
+            width: 22px;
+            height: 22px;
+            margin: 0 4px;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            border-radius: 8px;
+            cursor: pointer;
+            user-select: none;
+            color: #82849a;
+
+            &:hover,
+            &:active {
+                color: #d92d20;
+            }
+        }
+
+        &--focus {
+            border-color: #6388ff;
+        }
+
+        &--danger {
+            background-color: #fef3f2;
+            border-color: #fda29b;
+        }
+
+        & + & {
+            margin-top: 4px;
+        }
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/index.ts
index 71d1bb3ab0d8bb7277499ef8b973df3d5e892de4..bfdfc9bbc74351402f3625dadf24412a36f318c4 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/index.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/index.ts
@@ -6,6 +6,7 @@ import { AvatarUpload } from './avatar-upload';
 import { BranchEditor } from './branch-editor';
 import { ValueExpressionInput, useValueExpression } from './value-expression-input';
 import { VariableAssignEditor } from './variable-assign-editor';
+import { MethodInvokeExpress } from './method-invoke-express';
 
 /**
  * @description
@@ -19,6 +20,7 @@ registerCustomComponents([
     BranchEditor,
     ValueExpressionInput,
     VariableAssignEditor,
+    MethodInvokeExpress,
 ]);
 
 export {
@@ -29,12 +31,14 @@ export {
     BranchEditor,
     ValueExpressionInput,
     VariableAssignEditor,
+    MethodInvokeExpress,
 
     useValueExpression,
 };
 
 export * from './node-wrapper';
 export * from './type-selector';
+export * from './basic-type-selector';
 export * from './param-tag-list';
 export * from './node-content-wrapper';
 export * from './node-field';
@@ -43,3 +47,4 @@ export * from './condition-editor';
 export * from './selector-branches';
 export * from './single-param-value-tag';
 export * from './variable-assign-list';
+export * from './enum-input-help';
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/input-params.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/input-params.component.tsx
index f6d797d4a6f4cf074503387ffd121a39fd71225e..2ae08c7d345245168d96f19a6711ed3d5ef54523 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/input-params.component.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/input-params.component.tsx
@@ -70,7 +70,7 @@ export default defineComponent({
       emitChange([...params.value]);
     }
 
-    function onUpdateParamValue(param: Parameter, newValue: ValueExpress, newType: TypeRefer): void {
+    function onUpdateParamValue(param: Parameter, newValue: ValueExpress, newType?: TypeRefer): void {
       // 检查参数是否可编辑
       if (param.readOnly === true) {
         return;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/schema/input-params.schema.json b/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/schema/input-params.schema.json
index c2d3be71487e43e8d93a42aa7184fd49ee07c900..ea5afcde43422e03eb48751e69bd42801b96ebf0 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/schema/input-params.schema.json
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/input-params/src/schema/input-params.schema.json
@@ -21,7 +21,7 @@
     },
     "typeFilter": {
       "description": "typeFilter",
-      "type": "function"
+      "type": "object"
     },
     "paramCodeColumnTitle": {
       "description": "paramCodeColumnTitle",
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/constants.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/constants.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df70d9f13c95feb4d733f35368ef2f487178c796
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/constants.ts
@@ -0,0 +1,10 @@
+/** Indent width of each level of tree */
+export const TreeIndentWidth = 20;
+
+/** Tree Node Expand Collapse Button Width */
+export const TreeCollapseWidth = 16;
+
+/** Maximum depth limit */
+export const MAX_LEVEL = 3;
+
+export const ParamPaddingLeft = 4;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..36639a446e6c248afb795f61f1d962acd9a5e5e8
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/index.ts
@@ -0,0 +1,5 @@
+export * from './type';
+export * from './constants';
+export * from './use-data';
+export * from './use-columns-style';
+export * from './use-details';
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/type.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/type.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ccbe7eb5331b5c436d3feeaf6d5538953af14db2
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/type.ts
@@ -0,0 +1,15 @@
+import type { TTreeNodeData } from '@farris/flow-devkit/third-party';
+import type { Parameter, JsonSchema } from '@farris/flow-devkit/types';
+
+export type RowDataType = 'param' | 'schema';
+
+export interface RowData {
+    type: RowDataType;
+    level: number;
+    parameter: Parameter;
+    schema?: JsonSchema;
+}
+
+export interface TreeNodeData extends TTreeNodeData<string> {
+    rowData: RowData;
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-columns-style.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-columns-style.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a1ae475e0b126dc216dc83501ea766901cc85ca1
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-columns-style.ts
@@ -0,0 +1,22 @@
+import { type CSSProperties } from 'vue';
+import { TreeIndentWidth } from './constants';
+
+interface ColumnsStyle {
+    name: CSSProperties;
+    type: CSSProperties;
+}
+
+export function useColumnsStyle(level = 0, columnsRatio = '4:3'): ColumnsStyle {
+    const [nameWidth, typeWidth] = columnsRatio.split(':').map(Number);
+
+    return {
+        name: {
+            flex: `${nameWidth} ${nameWidth} 0px`,
+        },
+        type: {
+            flex: `${typeWidth} ${typeWidth} ${(level * TreeIndentWidth * typeWidth) / nameWidth}px`,
+            minWidth: '80px',
+            maxWidth: '135px',
+        },
+    };
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-data.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-data.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e10f096d02e35cd38b65841b8260b2f6922bfa1a
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-data.ts
@@ -0,0 +1,207 @@
+import { ref, watch, computed, reactive, type Ref, type Reactive } from 'vue';
+import type { SetupContext } from 'vue';
+import { JsonSchemaBasicType, type JsonSchema, type Parameter } from '@farris/flow-devkit/types';
+import type { JsonSchemaEditorProps } from '../json-schema-editor.props';
+import type { TreeNodeData } from './type';
+import { JsonSchemaUtils, uuid } from '@farris/flow-devkit/utils';
+import type { TTreeNodeModel } from '@farris/flow-devkit/third-party';
+import { useNotify } from '@farris/flow-devkit/composition';
+
+export interface UseData {
+    params: Ref<Parameter[]>;
+    allCodes: Ref<string[]>;
+    allNames: Ref<string[]>;
+    treeData: Ref<TreeNodeData[]>;
+    couldCollapse: Ref<boolean>;
+    expandedNodeValues: Ref<string[]>;
+    detailExpandedNodeValues: Reactive<Set<string>>;
+    onNodeExpand: (node: TTreeNodeModel) => void;
+    expandNodeByValue: (nodeValue: string) => void;
+    toggleNodeDetailPanel: (node: TTreeNodeModel) => void;
+    isParamNameDuplicate: (name?: string) => boolean;
+}
+
+export function useData(props: JsonSchemaEditorProps, _context: SetupContext): UseData {
+
+    const notify = useNotify();
+
+    const params = computed(() => props.modelValue || []);
+
+    const treeData = ref<TreeNodeData[]>([]);
+
+    const allNodeValues = reactive(new Set<string>());
+
+    const notExpandedNodeValues = reactive(new Set<string>());
+
+    const expandedNodeValues = computed<string[]>(() => {
+        const values: string[] = [];
+        allNodeValues.forEach((nodeValue) => {
+            if (!notExpandedNodeValues.has(nodeValue)) {
+                values.push(nodeValue);
+            }
+        });
+        return values;
+    });
+
+    const couldCollapse = computed<boolean>(() => {
+        return params.value.some((param) => {
+            const properties = JsonSchemaUtils.getObjectProperties(param.schema);
+            return Array.isArray(properties) && properties.length > 0;
+        });
+    });
+
+    function onNodeExpand(node: TTreeNodeModel): void {
+        const nodeValue = node.value as string;
+        if (!nodeValue) {
+            return;
+        }
+        if (node.expanded) {
+            notExpandedNodeValues.delete(nodeValue);
+        } else {
+            notExpandedNodeValues.add(nodeValue);
+        }
+    }
+
+    function expandNodeByValue(nodeValue: string): void {
+        notExpandedNodeValues.delete(nodeValue);
+    }
+
+    const allCodes = computed<string[]>(() => {
+        return params.value.map(param => param.code);
+    });
+
+    const allNames = computed<string[]>(() => {
+        return params.value.map(param => (param.name || '').trim() || param.code || '');
+    });
+
+    function isParamNameDuplicate(name?: string): boolean {
+        const trimmedName = (name || '').trim();
+        if (!trimmedName) {
+            return false;
+        }
+        const sames = allNames.value.filter((item) => item === trimmedName);
+        return sames.length > 1;
+    }
+
+    const detailExpandedNodeValues = reactive(new Set<string>());
+
+    function toggleNodeDetailPanel(node: TTreeNodeModel): void {
+        const nodeValue = node.value as string;
+        if (!nodeValue) {
+            return;
+        }
+        const { parameter, schema } = (node.data as TreeNodeData).rowData;
+        const paramName = schema ? '' : parameter.name;
+        const isNameDuplicate = isParamNameDuplicate(paramName);
+        const errorTip = isNameDuplicate ? `显示名称不可重复` : '';
+        if (detailExpandedNodeValues.has(nodeValue)) {
+            if (errorTip) {
+                notify.error(errorTip);
+            } else {
+                detailExpandedNodeValues.delete(nodeValue);
+            }
+        } else {
+            detailExpandedNodeValues.add(nodeValue);
+        }
+    }
+
+    function ensureId(item: Parameter | JsonSchema): void {
+        if (item && !item.id) {
+            item.id = uuid();
+        }
+    }
+
+    function transJsonSchema2TreeNodeData(param: Parameter, schema?: JsonSchema, level = 0): TreeNodeData[] {
+        if (!schema) {
+            return [];
+        }
+        if (schema.type === JsonSchemaBasicType.Array) {
+            return transJsonSchema2TreeNodeData(param, schema.items, level);
+        }
+        if (schema.type === JsonSchemaBasicType.Object && Array.isArray(schema.properties)) {
+            return schema.properties.map((property) => {
+                ensureId(property);
+                const nodeLabel = property.name || property.code;
+                const nodeValue = property.id!;
+                allNodeValues.add(nodeValue);
+                return {
+                    value: nodeValue,
+                    label: nodeLabel,
+                    text: nodeLabel,
+                    rowData: {
+                        type: 'schema',
+                        level,
+                        parameter: param,
+                        schema: property,
+                    },
+                    children: transJsonSchema2TreeNodeData(param, property, level + 1),
+                };
+            });
+        }
+        return [];
+    }
+
+    function transParameter2TreeNodeData(param: Parameter): TreeNodeData {
+        ensureId(param);
+        const nodeLabel = param.name || param.code;
+        const nodeValue = param.id!;
+        allNodeValues.add(nodeValue);
+        return {
+            value: nodeValue,
+            label: nodeLabel,
+            text: nodeLabel,
+            rowData: {
+                type: 'param',
+                level: 0,
+                parameter: param,
+            },
+            children: transJsonSchema2TreeNodeData(param, param.schema, 1),
+        };
+    }
+
+    function updateTreeNodeStatuses(): void {
+        Array.from(notExpandedNodeValues).forEach((nodeValue) => {
+            if (!allNodeValues.has(nodeValue)) {
+                notExpandedNodeValues.delete(nodeValue);
+            }
+        });
+        Array.from(detailExpandedNodeValues).forEach((nodeValue) => {
+            if (!allNodeValues.has(nodeValue)) {
+                detailExpandedNodeValues.delete(nodeValue);
+            }
+        });
+        if (!props.hideDetailExpandButton && props.canEditName) {
+            params.value.forEach((param) => {
+                if (isParamNameDuplicate(param.name)) {
+                    detailExpandedNodeValues.add(param.id!);
+                }
+            });
+        }
+    }
+
+    function updateTreeData(parameters: Parameter[]): void {
+        allNodeValues.clear();
+        treeData.value = parameters.filter((param) => !!param).map(transParameter2TreeNodeData);
+        updateTreeNodeStatuses();
+    }
+
+    watch(
+        params,
+        () => updateTreeData(params.value),
+        { immediate: true },
+    );
+
+    return {
+        params,
+        allCodes,
+        allNames,
+        treeData,
+        couldCollapse,
+        expandedNodeValues,
+        detailExpandedNodeValues,
+        onNodeExpand,
+        expandNodeByValue,
+        toggleNodeDetailPanel,
+        isParamNameDuplicate,
+    };
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-details.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-details.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..9fe9756f621d12a1f197b3831e3c02578aa04947
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/composition/use-details.tsx
@@ -0,0 +1,116 @@
+import { type JsonSchemaEditorProps, COMPONENT_NAME } from '../json-schema-editor.props';
+import { type TTreeNodeModel } from '@farris/flow-devkit/third-party';
+import type { TreeNodeData, RowData } from './type';
+import type { UseData } from './use-data';
+import { useBem, ParameterUtils } from '@farris/flow-devkit/utils';
+import { BasicTypeRefer, type EnumInputHelp } from '@farris/flow-devkit/types';
+import { EnumInputHelpEditor } from '@farris/flow-devkit/form-materials';
+
+export function useDetails(props: JsonSchemaEditorProps, useDataComposition: UseData) {
+
+    const { bem } = useBem(COMPONENT_NAME);
+    const {
+        isParamNameDuplicate,
+    } = useDataComposition;
+
+    function renderErrorTip(errorTip?: string) {
+        if (!errorTip) {
+            return;
+        }
+        return (
+            <div class="fvf-form-item-error" title={errorTip}>{errorTip}</div>
+        );
+    }
+
+    function renderParamNameInput(rowData: RowData) {
+        const { parameter } = rowData;
+        const paramName = parameter.name || '';
+        const isDuplicate = isParamNameDuplicate(paramName);
+        const errorTip = isDuplicate ? `显示名称不可重复` : '';
+
+        return <>
+            <f-input-group
+                modelValue={paramName}
+                enableClear={true}
+                placeholder={'请输入显示名称'}
+                customClass={errorTip ? 'fvf-error-state' : undefined}
+                onUpdate:modelValue={(newName: string) => {
+                    parameter.name = newName;
+                }}
+            />
+            {renderErrorTip(errorTip)}
+        </>;
+    }
+
+    function renderParamDescriptionInput(rowData: RowData) {
+        const { parameter, schema } = rowData;
+        const description = schema ? schema.description : parameter.description;
+        return (
+            <f-input-group
+                modelValue={description || ''}
+                enableClear={true}
+                placeholder={'请输入参数描述'}
+                onUpdate:modelValue={(newDescription: string) => {
+                    if (schema) {
+                        schema.description = newDescription;
+                    } else {
+                        parameter.description = newDescription;
+                    }
+                }}
+            />
+        );
+    }
+
+    function renderInputHelp(rowData: RowData) {
+        const { parameter, schema } = rowData;
+        const showInputHelp = !schema && props.canEditInputHelp;
+        if (!showInputHelp) {
+            return;
+        }
+        const paramType = parameter.type;
+        if (ParameterUtils.isSame(paramType, BasicTypeRefer.StringType)) {
+            return (
+                <div class={bem('field')}>
+                    <div class={bem('field-label')} title="如果选项非空，则在“试运行面板”中通过下拉列表输入本参数">下拉选项</div>
+                    <div class={bem('field-content')}>
+                        <EnumInputHelpEditor
+                            modelValue={parameter.inputHelp as EnumInputHelp}
+                            onUpdate:modelValue={(newValue) => {
+                                parameter.inputHelp = newValue;
+                            }}
+                        />
+                    </div>
+                </div>
+            );
+        }
+    }
+
+    function renderParamDetails(item: TTreeNodeModel) {
+        const nodeData = item.data as TreeNodeData;
+        const rowData = nodeData.rowData;
+        const { schema } = rowData;
+
+        const showNameField = !!props.canEditName && !schema;
+
+        return (
+            <div class={bem('param-details')}>
+                {showNameField && (
+                    <div class={bem('field')}>
+                        <div class={bem('field-label')} title="参数的显示名称，用于在“试运行面板”中显示">显示名称</div>
+                        <div class={bem('field-content')}>{renderParamNameInput(rowData)}</div>
+                    </div>
+                )}
+                <div class={bem('field')}>
+                    <div class={bem('field-label')} title="参数的描述，用于在“试运行面板”中显示">描述</div>
+                    <div class={bem('field-content')}>{renderParamDescriptionInput(rowData)}</div>
+                </div>
+                {renderInputHelp(rowData)}
+            </div>
+        );
+    }
+
+    return {
+        renderParamDetails,
+        renderErrorTip,
+    };
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.component.tsx
index e6db4f2c97e70dafdf9a580ee78c46377c474304..66382d86c69d712f824094f790275c5ae09639db 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.component.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.component.tsx
@@ -1,34 +1,69 @@
-import { defineComponent, computed } from 'vue';
-import { jsonSchemaEditorProps } from './json-schema-editor.props';
-import { useBem, uuid, ParamValidateUtils } from '@farris/flow-devkit/utils';
-import type { Parameter, TypeRefer, ParamValidateOptions } from '@farris/flow-devkit/types';
-import { BasicTypeRefer } from '@farris/flow-devkit/types';
-import { TypeSelector } from '@farris/flow-devkit/form-materials';
+import { defineComponent, computed, h, type CSSProperties } from 'vue';
+import { jsonSchemaEditorProps, COMPONENT_NAME } from './json-schema-editor.props';
+import { useBem, uuid, ParamValidateUtils, JsonSchemaUtils, ParameterUtils, InputHelpUtils } from '@farris/flow-devkit/utils';
+import {
+  TTree,
+  type TTreeNodeModel,
+  type TTreeNodeValue,
+} from '@farris/flow-devkit/third-party';
+import type { Parameter, TypeRefer, ParamValidateOptions, JsonSchema } from '@farris/flow-devkit/types';
+import { BasicTypeRefer, JsonSchemaBasicType } from '@farris/flow-devkit/types';
+import { TypeSelector, BasicTypeSelector } from '@farris/flow-devkit/form-materials';
+import {
+  useData,
+  useDetails,
+  useColumnsStyle,
+  TreeCollapseWidth,
+  ParamPaddingLeft,
+  MAX_LEVEL,
+  type RowData,
+  type TreeNodeData,
+} from './composition';
 
 import './json-schema-editor.scss';
 
-const name = 'FvfJsonSchemaEditor';
-
 /**
  * @description
  * 常用于可视化配置节点的输出变量。
  * 用于编辑一个`Parameter[]`，主要编辑`参数名`和`参数类型`，不编辑`参数值`。
- * 对标`Coze工作流`中`开始`节点的`输入`参数编辑器。
- * @todo
- * 初期暂不实现对`Object`和`Array<Object>`类型的嵌套定义。
  */
 export default defineComponent({
-  name,
+  name: COMPONENT_NAME,
   props: jsonSchemaEditorProps,
   emits: ['update:modelValue'],
   setup(props, context) {
-    const { bem } = useBem(name);
-    const params = computed(() => {
-      return props.modelValue || [];
+    const { bem } = useBem(COMPONENT_NAME);
+    const useDataComposition = useData(props, context as any);
+    const {
+      renderParamDetails,
+      renderErrorTip,
+    } = useDetails(props, useDataComposition);
+    const {
+      params,
+      allCodes,
+      treeData,
+      couldCollapse,
+      expandedNodeValues,
+      detailExpandedNodeValues,
+      onNodeExpand,
+      expandNodeByValue,
+      toggleNodeDetailPanel,
+    } = useDataComposition;
+
+    const hasAddSubLevelButtonColumn = computed<boolean>(() => {
+      if (props.readonly || props.hideAddSubLevelButton) {
+        return false;
+      }
+      return params.value.some((param) => JsonSchemaUtils.canEditJsonSchema(param.type) && !param.readOnly);
     });
 
-    const allCodes = computed<string[]>(() => {
-      return params.value.map(param => param.code);
+    const hasDeleteButtonColumn = computed<boolean>(() => !props.readonly);
+
+    const hasDetailExpandButtonColumn = computed<boolean>(() => {
+      if (props.readonly || props.hideDetailExpandButton) {
+        return false;
+      }
+      return params.value.some((param) => !param.readOnly);
     });
 
     function createNewParam(): Parameter {
@@ -45,103 +80,237 @@ export default defineComponent({
       context.emit('update:modelValue', newParams);
     }
 
-    function handleAdd(): void {
+    function generateParameterSchemaByTypeRefer(type: TypeRefer, param?: Parameter): JsonSchema | undefined {
+      const oldProperties = JsonSchemaUtils.getObjectProperties(param?.schema) || [];
+      if (ParameterUtils.isSame(BasicTypeRefer.ObjectType, type)) {
+        const schema = JsonSchemaUtils.createJsonSchemaByType(JsonSchemaBasicType.Object);
+        schema.properties = oldProperties;
+        return schema;
+      } else if (ParameterUtils.isSame(BasicTypeRefer.ObjectArrayType, type)) {
+        const schema = JsonSchemaUtils.createJsonSchemaByType(JsonSchemaBasicType.Array, JsonSchemaBasicType.Object);
+        schema.items!.properties = oldProperties;
+        return schema;
+      } else {
+        return undefined;
+      }
+    }
+
+    function handleAddParam(): void {
       const newParam = createNewParam();
       const newParams = [...params.value, newParam];
       emitChange(newParams);
     }
 
-    function handleDelete(target: Parameter): void {
-      // 检查参数是否可删除
-      if (target.readOnly === true) {
+    function handleAddSubLevelParam(rowData: RowData): void {
+      const { parameter, schema } = rowData;
+      if (!schema && !parameter.schema) {
+        parameter.schema = generateParameterSchemaByTypeRefer(parameter.type);
+      }
+      const parentSchema = schema || parameter.schema;
+      const properties = JsonSchemaUtils.getObjectProperties(parentSchema);
+      if (!properties) {
         return;
       }
-      const newParams = params.value.filter(param => param.id !== target.id);
-      emitChange(newParams);
+      properties.push(
+        JsonSchemaUtils.createJsonSchemaByType(JsonSchemaBasicType.String)
+      );
+      const currentNodeValue = schema?.id || parameter.id;
+      expandNodeByValue(currentNodeValue!);
+      emitChange([...params.value]);
     }
 
-    function onUpdateParamCode(param: Parameter, newCode: string): void {
-      // 检查参数是否可编辑
-      if (param.readOnly === true) {
-        return;
+    function handleDeleteParam(rowData: RowData): void {
+      const { parameter, schema } = rowData;
+      if (schema) {
+        const parentObjectSchema = JsonSchemaUtils.getParentObjectSchema(parameter.schema, schema);
+        if (!parentObjectSchema) {
+          return;
+        }
+        parentObjectSchema.properties = parentObjectSchema.properties!.filter((property) => {
+          return property.id !== schema.id;
+        });
+        emitChange([...params.value]);
+      } else {
+        const newParams = params.value.filter(param => param.id !== parameter.id);
+        emitChange(newParams);
       }
-      param.code = newCode;
-      emitChange([...params.value]);
     }
 
-    function onUpdateParamType(param: Parameter, newType: TypeRefer): void {
-      // 检查参数是否可编辑
-      if (param.readOnly === true) {
-        return;
+    function onUpdateParamCode(rowData: RowData, newCode: string): void {
+      const { parameter, schema } = rowData;
+      if (schema) {
+        schema.code = newCode;
+        schema.name = newCode;
+      } else {
+        parameter.code = newCode;
       }
+      emitChange(params.value);
+    }
+
+    function onUpdateParamType(param: Parameter, newType: TypeRefer): void {
       param.type = newType;
+      param.schema = generateParameterSchemaByTypeRefer(newType, param);
+      param.inputHelp = InputHelpUtils.getInputHelp(newType);
       emitChange([...params.value]);
     }
 
-    function renderTitleRow() {
+    function onUpdateSchemaType(schema: JsonSchema, newType: string): void {
+      JsonSchemaUtils.updateSchemaTypeBySelectorValue(schema, newType);
+      emitChange([...params.value]);
+    }
+
+    function handleNodeExpand(_value: TTreeNodeValue[], context: { node: TTreeNodeModel }): void {
+      const { node } = context;
+      onNodeExpand(node);
+    }
+
+    function renderBtnPlaceholder() {
       return (
-        <div class={bem('title-row')}>
-          <div class={bem('title-item')} style="flex: 3">参数名</div>
-          <div class={bem('title-item')} style="flex: 2">类型</div>
-          {!props.readonly && (
-            <div class={bem('placeholder')}></div>
-          )}
-        </div>
+        <div class={bem('btn-placeholder')}></div>
       );
     }
 
-    function renderErrorTip(errorTip?: string) {
-      if (!errorTip) {
-        return;
-      }
+    function renderTitleRow() {
+      const columnsStyle = useColumnsStyle();
+      const marginLeftValue = couldCollapse.value ? TreeCollapseWidth + ParamPaddingLeft : ParamPaddingLeft;
+      const titleRowStyle: CSSProperties = {
+        marginLeft: `${marginLeftValue}px`,
+      };
+
       return (
-        <div class="fvf-form-item-error" title={errorTip}>{errorTip}</div>
+        <div class={bem('title-row')} style={titleRowStyle}>
+          <div class={bem('title-item')} style={columnsStyle.name}>参数名</div>
+          <div class={bem('title-item')} style={columnsStyle.type}>类型</div>
+          {hasDetailExpandButtonColumn.value && renderBtnPlaceholder()}
+          {hasAddSubLevelButtonColumn.value && renderBtnPlaceholder()}
+          {hasDeleteButtonColumn.value && renderBtnPlaceholder()}
+        </div>
       );
     }
 
-    function renderParamItem(param: Parameter) {
+    function renderParamCodeInput(rowData: RowData, readonly: boolean) {
+      const { parameter, schema } = rowData;
+      const paramCode = schema ? schema.code : parameter.code;
+      const parentObjectSchema = JsonSchemaUtils.getParentObjectSchema(parameter.schema, schema);
       const validateOptions: ParamValidateOptions = {
         ...props.validateOptions,
-        getAllCodes: () => allCodes.value,
+        getAllCodes: () => {
+          if (!schema) {
+            return allCodes.value;
+          }
+          return parentObjectSchema?.properties?.map(item => item.code) || [];
+        },
       };
-      const codeError = ParamValidateUtils.validateCode(param.code, validateOptions);
+      const codeError = ParamValidateUtils.validateCode(paramCode, validateOptions);
 
-      // 检查参数是否可编辑，如果不可编辑则所有字段都只读
-      const isParamReadonly = props.readonly || param.readOnly === true;
-      // 检查是否显示删除按钮
-      const showDeleteBtn = !props.readonly && param.readOnly !== true;
+      return <>
+        <f-input-group
+          modelValue={paramCode}
+          enableClear={false}
+          placeholder={'输入参数名'}
+          readonly={readonly}
+          customClass={codeError ? 'fvf-error-state' : undefined}
+          onUpdate:modelValue={(newCode: string) => onUpdateParamCode(rowData, newCode)}
+        />
+        {renderErrorTip(codeError)}
+      </>;
+    }
 
+    function renderParamTypeSelector(rowData: RowData, readonly: boolean) {
+      const { parameter, schema, level } = rowData;
+      if (!schema) {
+        return (
+          <TypeSelector
+            modelValue={parameter.type}
+            readonly={readonly}
+            onUpdate:modelValue={(newType) => onUpdateParamType(parameter, newType)}
+          />
+        );
+      }
       return (
-        <div class={bem('param')} key={param.id}>
-          <div class={bem('input-item')} style="flex: 3">
-            <f-input-group
-              modelValue={param.code}
-              enableClear={false}
-              placeholder={'输入参数名'}
-              readonly={isParamReadonly}
-              customClass={codeError ? 'fvf-error-state' : undefined}
-              onUpdate:modelValue={(newCode: string) => onUpdateParamCode(param, newCode)}
-            ></f-input-group>
-            {renderErrorTip(codeError)}
-          </div>
-          <div class={bem('input-item')} style="flex: 2">
-            <TypeSelector
-              modelValue={param.type}
-              readonly={isParamReadonly}
-              onUpdate:modelValue={(newType) => onUpdateParamType(param, newType)}
-            ></TypeSelector>
-          </div>
-          {!props.readonly && (
-            <div class={bem('delete-btn')} onClick={() => handleDelete(param)}>
-              {showDeleteBtn && <i class="f-icon f-icon-enclosure_delete"></i>}
+        <BasicTypeSelector
+          modelValue={JsonSchemaUtils.transSchemaType2SelectorValue(schema)}
+          readonly={readonly}
+          disableObjectOptions={level >= MAX_LEVEL}
+          onUpdate:modelValue={(newType) => onUpdateSchemaType(schema, newType)}
+        />
+      );
+    }
+
+    function canAddSubLevel(rowData: RowData): boolean {
+      const { parameter, schema } = rowData;
+      if (schema) {
+        return JsonSchemaUtils.canAddSubLevel(schema);
+      }
+      return JsonSchemaUtils.canEditJsonSchema(parameter.type);
+    }
+
+    function renderParamItem(_: typeof h, item: TTreeNodeModel) {
+      const nodeData = item.data as TreeNodeData;
+      const nodeValue = item.value as string;
+      const rowData = nodeData.rowData;
+      const { parameter, level } = rowData;
+      const columnsStyle = useColumnsStyle(level);
+
+      const isParamReadonly = props.readonly || parameter.readOnly === true;
+      const showDetailExpandButton = !isParamReadonly && !props.hideDetailExpandButton;
+      const showAddSubLevelButton = !isParamReadonly && !props.hideAddSubLevelButton && canAddSubLevel(rowData);
+      const showDeleteButton = !isParamReadonly;
+      const showDetail = showDetailExpandButton && detailExpandedNodeValues.has(nodeValue);
+
+      return (
+        <div class={[bem('param'), showDetail && bem('param', 'details')]}>
+          <div class={bem('param-main')}>
+            <div class={bem('input-item')} style={columnsStyle.name}>
+              {renderParamCodeInput(rowData, isParamReadonly)}
+            </div>
+            <div class={bem('input-item')} style={columnsStyle.type}>
+              {renderParamTypeSelector(rowData, isParamReadonly)}
             </div>
-          )}
+            {showDetailExpandButton ? (
+              <div class={[bem('tool-btn'), showDetail && 'active']}
+                title="展开详情"
+                onClick={() => toggleNodeDetailPanel(item)}>
+                <i class="f-icon f-icon-new-fullscreen app-font-14"></i>
+              </div>
+            ) : (hasDetailExpandButtonColumn.value && renderBtnPlaceholder())}
+            {showAddSubLevelButton ? (
+              <div class={bem('tool-btn')}
+                title="新增子项"
+                onClick={() => handleAddSubLevelParam(rowData)}>
+                <i class="f-icon f-icon-list-new"></i>
+              </div>
+            ) : (hasAddSubLevelButtonColumn.value && renderBtnPlaceholder())}
+            {showDeleteButton ? (
+              <div class={bem('tool-btn')}
+                title="删除"
+                onClick={() => handleDeleteParam(rowData)}>
+                <i class="f-icon f-icon-enclosure_delete"></i>
+              </div>
+            ) : (hasDeleteButtonColumn.value && renderBtnPlaceholder())}
+          </div>
+          {showDetail && renderParamDetails(item)}
         </div>
       );
     }
 
+    function emptySlot() {
+      return <></>;
+    }
+
     function renderParams() {
-      return params.value.map(param => renderParamItem(param));
+      return (
+        <TTree
+          data={treeData.value}
+          line={true}
+          transition={false}
+          hover={false}
+          label={renderParamItem}
+          expanded={expandedNodeValues.value}
+          empty={emptySlot}
+          onExpand={handleNodeExpand}
+        ></TTree>
+      );
     }
 
     function renderAddButton() {
@@ -154,15 +323,20 @@ export default defineComponent({
             class={bem('add')}
             type="secondary"
             icon="f-icon-add"
-            onClick={handleAdd}
+            onClick={handleAddParam}
           >新增</f-button>
-          <div class={bem('placeholder')}></div>
+          {hasDeleteButtonColumn.value && renderBtnPlaceholder()}
         </div>
       );
     }
 
+    const editorClass = computed(() => ({
+      [bem()]: true,
+      [bem('', 'could-collapse')]: couldCollapse.value,
+    }));
+
     return () => (
-      <div class={bem()}>
+      <div class={editorClass.value}>
         {renderTitleRow()}
         {renderParams()}
         {renderAddButton()}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.props.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.props.ts
index 22ef5fbef2a667b0e15f66cf40fe7810fe2fc5ef..7a2bd546aa2e8554ff818921a437257c018071fd 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.props.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.props.ts
@@ -3,6 +3,8 @@ import { createPropsResolver } from '@farris/ui-vue';
 import jsonSchemaEditorSchema from './schema/json-schema-editor.schema.json';
 import type { Parameter, ParamValidateOptions } from '@farris/flow-devkit/types';
 
+export const COMPONENT_NAME = 'FvfJsonSchemaEditor';
+
 export const jsonSchemaEditorProps = {
 
     /** 绑定值，参数列表 */
@@ -13,6 +15,18 @@ export const jsonSchemaEditorProps = {
 
     /** 校验选项 */
     validateOptions: { type: Object as PropType<ParamValidateOptions> },
+
+    /** 不显示`新增子项`按钮 */
+    hideAddSubLevelButton: { type: Boolean, default: false },
+
+    /** 不显示`展开详情`按钮 */
+    hideDetailExpandButton: { type: Boolean, default: false },
+
+    /** 是否编辑`显示名称`字段 */
+    canEditName: { type: Boolean, default: false },
+
+    /** 是否编辑`输入帮助设置`相关的字段 */
+    canEditInputHelp: { type: Boolean, default: false },
 };
 
 export type JsonSchemaEditorProps = ExtractPropTypes<typeof jsonSchemaEditorProps>;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.scss
index 413b02c651cd5f76aedc4dbec5aa735a6da8279b..06758cd44346bc4870eba8b42947187e62b23332 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.scss
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/json-schema-editor.scss
@@ -1,3 +1,45 @@
+.fvf-json-schema-editor {
+    .t-tree__line {
+        height: auto !important;
+        top: -16px;
+
+        &::before {
+            height: 100% !important;
+        }
+
+        &--leaf::before {
+            width: 28px !important;
+        }
+    }
+
+    .t-tree__item {
+        .t-tree__icon.t-folder-icon {
+            & {
+                align-self: flex-end;
+                bottom: 13px;
+            }
+        }
+
+        .t-tree__label {
+            padding: 0;
+            margin-left: 0;
+            cursor: default;
+            &::selection {
+                background-color: #5d59ca;
+                color: #ffffff;
+            }
+        }
+    }
+}
+
+.fvf-json-schema-editor:not(.fvf-json-schema-editor--could-collapse) {
+    .t-tree__item {
+        .t-tree__icon.t-folder-icon:empty {
+            display: none;
+        }
+    }
+}
+
 .fvf-json-schema-editor {
     display: block;
     margin-top: 8px;
@@ -16,28 +58,54 @@
         padding-bottom: 8px;
     }
 
-    &__placeholder {
-        width: 24px;
+    &__btn-placeholder {
+        width: 26px;
     }
 
     &__param {
         display: flex;
-        align-items: flex-start;
-        padding-bottom: 4px;
-        gap: 4px;
+        flex-direction: column;
+        border-radius: 9px;
+        padding: 4px;
+        margin-bottom: 4px;
+
+        &-main {
+            display: flex;
+            align-items: flex-start;
+            gap: 4px;
+        }
+
+        &-details {
+            width: 100%;
+        }
+
+        &--details {
+            background-color: rgba(200, 206, 218, 0.18);
+        }
     }
 
     &__input-item {
         min-width: 0px;
     }
 
-    &__delete-btn {
+    &__field {
+        &-label {
+            margin-top: 8px;
+            margin-bottom: 4px;
+            line-height: 16px;
+            font-size: 12px;
+            color: rgba(32, 41, 69, 0.62);
+            font-weight: 400;
+        }
+    }
+
+    &__tool-btn {
         display: flex;
         overflow: hidden;
         justify-content: center;
         align-items: center;
-        width: 24px;
-        height: 24px;
+        width: 26px;
+        height: 26px;
         border-radius: 5px;
         user-select: none;
         cursor: pointer;
@@ -45,6 +113,9 @@
         &:hover {
             background-color: rgba(87, 104, 161, 0.08);
         }
+        &.active {
+            background-color: rgba(87, 104, 161, 0.12);
+        }
 
         i {
             color: #82849a;
@@ -57,6 +128,7 @@
         gap: 4px;
         overflow: hidden;
         margin-top: 2px;
+        margin-left: 4px;
     }
 
     &__add.btn {
@@ -66,3 +138,15 @@
         font-size: 13px;
     }
 }
+
+.app-font {
+    &-16 {
+        font-size: 16px !important;
+    }
+    &-15 {
+        font-size: 15px !important;
+    }
+    &-14 {
+        font-size: 14px !important;
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/schema/json-schema-editor.schema.json b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/schema/json-schema-editor.schema.json
index aeb8c4aff6842b44635a30e772ea93d316032eae..79ca113d57529d77b02b2a22ac4dce712d2d68dc 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/schema/json-schema-editor.schema.json
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/json-schema-editor/src/schema/json-schema-editor.schema.json
@@ -22,6 +22,26 @@
     "validateOptions": {
       "description": "validateOptions",
       "type": "object"
+    },
+    "hideAddSubLevelButton": {
+      "description": "hideAddSubLevelButton",
+      "type": "boolean",
+      "default": false
+    },
+    "hideDetailExpandButton": {
+      "description": "hideDetailExpandButton",
+      "type": "boolean",
+      "default": false
+    },
+    "canEditName": {
+      "description": "canEditName",
+      "type": "boolean",
+      "default": false
+    },
+    "canEditInputHelp": {
+      "description": "canEditInputHelp",
+      "type": "boolean",
+      "default": false
     }
   },
   "required": ["id", "type"]
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f02c6aaee9d4e7e0f36caa29f3ba8b5639e18c5a
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/index.ts
@@ -0,0 +1,13 @@
+import MethodInvokeExpressInstallless from './src/method-invoke-express.component';
+import { withInstall, withRegister } from '@farris/flow-devkit/types';
+import { propsResolver } from './src/method-invoke-express.props';
+
+const COMPONENT_NAME = 'fvf-method-invoke-express';
+
+const MethodInvokeExpress = withInstall(MethodInvokeExpressInstallless);
+withRegister(MethodInvokeExpress, { name: COMPONENT_NAME, propsResolver });
+
+export {
+    MethodInvokeExpress,
+};
+export default MethodInvokeExpress;
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..465a5d30031f22a5c73f78deeb95bbf483bb820c
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/index.ts
@@ -0,0 +1 @@
+export { default as MethodTypeSelect } from './method-type-select';
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/method-type-select.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/method-type-select.scss
similarity index 100%
rename from ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/method-type-select.scss
rename to ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/method-type-select.scss
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/method-type-select.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/method-type-select.tsx
similarity index 98%
rename from ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/method-type-select.tsx
rename to ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/method-type-select.tsx
index 6b0ea3d6f12139e2a5d521954696080d8beb07ce..5ddfa59cd7aa49f6e1e33187e8b68f6aca5ab1c6 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/method-type-select.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/components/method-type-select.tsx
@@ -128,8 +128,8 @@ export default defineComponent({
       { field: 'name', title: '类型名称', width: 100, resizable: true, dataType: 'string' },
     ];
     const methodGridColumns = [
-      { field: 'code', title: '方法编号', width: 100, resizable: true, dataType: 'string' },
-      { field: 'name', title: '方法名称', width: 100, resizable: true, dataType: 'string' },
+      { field: 'code', title: '函数编号', width: 100, resizable: true, dataType: 'string' },
+      { field: 'name', title: '函数名称', width: 100, resizable: true, dataType: 'string' },
     ];
 
     const typeGridData = computed(() => {
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.component.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..0ad950f724c52044699603a245b12036e893cd31
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.component.tsx
@@ -0,0 +1,337 @@
+import { defineComponent, ref, computed, watch, onMounted } from 'vue';
+import { METHOD_INVOKE_EXPRESS_NAME, methodInvokeExpressProps } from './method-invoke-express.props';
+import { useBem, ValueExpressUtils } from '@farris/flow-devkit/utils';
+import type { MethodInvokeExpr, ValueExpress, TypeRefer, Type, TypeMethod, Parameter, MethodParameter, ValueExpressionResult } from '@farris/flow-devkit/types';
+import { ValueExpressKind } from '@farris/flow-devkit/types';
+import { useMethodTypes } from '@farris/flow-devkit/hooks';
+import { getNodeVariables, getWritableNodeVariables, useTypeDetails } from '@farris/flow-devkit/composition';
+import { TSelect } from "@farris/flow-devkit/third-party";
+import { MethodTypeSelect } from './components';
+import { ValueExpressionInput } from '@farris/flow-devkit/form-materials/value-expression-input';
+
+import './method-invoke-express.scss';
+
+const NO_METHOD_TYPE_TIP = '请先选择类型';
+const NO_METHOD_TIP = '请选择函数';
+
+export default defineComponent({
+  name: METHOD_INVOKE_EXPRESS_NAME,
+  props: methodInvokeExpressProps,
+  emits: {
+    'update:modelValue': (
+      _newValue: ValueExpress | undefined,
+      _: ValueExpress | undefined,
+      _result: ValueExpressionResult,
+    ) => {
+      return true;
+    }
+  },
+  setup(props, context) {
+    const { bem } = useBem(METHOD_INVOKE_EXPRESS_NAME);
+    const { mergedMethodTypes, refreshMethodTypes } = useMethodTypes();
+
+    const currentTypeRefer = ref<TypeRefer>();
+    const currentMethodCode = ref<string>();
+    const paramValues = ref<Record<string, ValueExpress>>({});
+
+    const nodeVariables = props.nodeVariables ? props.nodeVariables : getNodeVariables();
+    const writableNodeVariables = props.writableNodeVariables ? props.writableNodeVariables : getWritableNodeVariables();
+    const {
+      getTypeCode,
+      getTypeName,
+      loadType,
+      isListType,
+    } = useTypeDetails();
+
+    const currentMethodType = computed<Type | undefined>(() => {
+      const typeRefer = currentTypeRefer.value;
+      if (!typeRefer) {
+        return;
+      }
+      return mergedMethodTypes.value.find((type) => {
+        return type.source === typeRefer.source && type.typeId === typeRefer.typeId;
+      });
+    });
+
+    const currentMethods = computed<TypeMethod[]>(() => {
+      return currentMethodType.value?.methods || [];
+    });
+
+    const methodOptions = computed(() => {
+      return currentMethods.value.map((method) => ({
+        label: method.name || method.code,
+        value: method.code,
+      }));
+    });
+
+    const currentMethod = computed<TypeMethod | undefined>(() => {
+      return currentMethods.value.find((method) => {
+        return method.code === currentMethodCode.value;
+      });
+    });
+
+    const currentParameters = computed<Parameter[]>(() => {
+      return currentMethod.value?.parameters || [];
+    });
+
+    const shouldShowParams = computed<boolean>(() => !!currentMethod.value);
+
+    function getErrorTip(): string | undefined {
+      const method = currentMethod.value;
+      if (!method) {
+        return '请选择一个函数';
+      }
+      const returnType = method.returnType;
+      if (props.onlyAllowArrayType && !isListType(returnType)) {
+        return '只能选择返回值为数组的函数';
+      }
+      return undefined;
+    }
+
+    function getNewValue(): ValueExpressionResult {
+      const errorTip = getErrorTip();
+      const method = currentMethod.value;
+      if (!method) {
+        return { errorTip };
+      }
+      const returnType = method.returnType;
+      const methodParams: MethodParameter[] = [];
+      currentParameters.value.forEach((param) => {
+        const paramValue = paramValues.value[param.code];
+        if (paramValue) {
+          methodParams.push({
+            code: param.code,
+            value: paramValue,
+          });
+        }
+      });
+      const express = ValueExpressUtils.createMethodInvokeExpr(
+        currentMethodType.value!.typeId,
+        method.code,
+        methodParams,
+      );
+      return {
+        express,
+        type: returnType,
+        errorTip,
+      };
+    }
+
+    function emitNewValue(): void {
+      const result = getNewValue();
+      context.emit('update:modelValue', result.express, result.express, result);
+    }
+
+    function onUpdateMethodType(typeRefer: TypeRefer, methodCode?: string): void {
+      currentTypeRefer.value = typeRefer;
+      currentMethodCode.value = undefined;
+      if (methodCode) {
+        currentMethodCode.value = methodCode;
+      }
+      emitNewValue();
+    }
+
+    function onMethodSelectChange(newValue: any): void {
+      currentMethodCode.value = newValue;
+      emitNewValue();
+    }
+
+    function refreshMethodList(): void {
+      refreshMethodTypes();
+    }
+
+    onMounted(refreshMethodList);
+
+    function initParamValues(): void {
+      paramValues.value = {};
+    }
+
+    function loadAllTypes(): void {
+      const method = currentMethod.value;
+      if (!method) {
+        return;
+      }
+      const typeRefers: TypeRefer[] = [];
+      if (method.returnType) {
+        typeRefers.push(method.returnType);
+      }
+      (method.parameters || []).forEach(param => {
+        if (param?.type) {
+          typeRefers.push(param.type);
+        }
+      });
+      if (typeRefers.length) {
+        loadType(typeRefers);
+      }
+    }
+
+    watch(currentMethod, (newValue, oldValue) => {
+      if (!oldValue) {
+        return;
+      }
+      if (newValue?.code !== oldValue.code) {
+        initParamValues();
+      }
+    });
+    watch(currentMethod, loadAllTypes, { immediate: true });
+
+    function updateInnerValue(currentValue?: ValueExpress): void {
+      if (currentValue?.kind !== ValueExpressKind.methodInvoke) {
+        return;
+      }
+      const express = currentValue as MethodInvokeExpr;
+      if (!express.typeUrl) {
+        return;
+      }
+      currentTypeRefer.value = {
+        source: 'default',
+        typeId: express.typeUrl,
+      };
+      currentMethodCode.value = express.methodCode;
+      const params: Record<string, ValueExpress> = {};
+      (express.parameters || []).forEach((param) => {
+        if (param && param.code && param.value) {
+          params[param.code] = param.value;
+        }
+      });
+      paramValues.value = params;
+    }
+
+    watch(
+      () => props.modelValue,
+      () => updateInnerValue(props.modelValue),
+      { immediate: true },
+    );
+
+    context.expose({
+      refreshMethodList,
+      getNewValue,
+    });
+
+    function renderParameter(param: Parameter) {
+      const keyID = `${currentMethodType.value!.typeId}_${currentMethod.value!.code}_${param.code}`;
+      const paramName = param.name || param.code;
+      const paramCode = param.code;
+      const paramTitle = `${paramName} - ${paramCode}`;
+      const typeCode = getTypeCode(param.type);
+      const typeName = getTypeName(param.type);
+      return (
+        <div class={bem('param-item')} key={keyID}>
+          <div class={bem('param-item-header')}>
+            <div class={bem('param-item-label')} title={paramTitle}>{param.name || param.code}</div>
+            {typeCode && (
+              <div class={bem('type')} title={typeName}>{typeCode}</div>
+            )}
+          </div>
+          <div class={bem('param-item-editor')}>
+            <ValueExpressionInput
+              modelValue={paramValues.value[param.code]}
+              nodeVariables={nodeVariables}
+              writableNodeVariables={writableNodeVariables}
+              onUpdate:modelValue={(newValue) => {
+                paramValues.value[param.code] = newValue;
+                emitNewValue();
+              }}
+            />
+          </div>
+        </div>
+      );
+    }
+
+    function renderMethodTypeSelect() {
+      return (
+        <MethodTypeSelect
+          value={currentTypeRefer.value}
+          onUpdate:value={onUpdateMethodType}
+        />
+      );
+    }
+
+    function renderMethodSelect() {
+      return (
+        <TSelect
+          value={currentMethodCode.value}
+          options={methodOptions.value}
+          clearable={false}
+          size={'small'}
+          placeholder={currentMethodType.value ? NO_METHOD_TIP : NO_METHOD_TYPE_TIP}
+          onChange={onMethodSelectChange}
+        />
+      );
+    }
+
+    function renderReturnType() {
+      const returnType = currentMethod.value!.returnType;
+      const typeCode = getTypeCode(returnType) || '无';
+      const typeName = getTypeName(returnType);
+      return (
+        <div class={bem('type')} title={typeName}>{typeCode}</div>
+      );
+    }
+
+    function renderParamListPlaceholder() {
+      if (currentParameters.value.length) {
+        return;
+      }
+      return (
+        <div class={bem('no-param')}>{'参数列表为空'}</div>
+      );
+    }
+
+    const errorTip = computed<string>(() => {
+      if (!currentMethodType.value) {
+        return NO_METHOD_TYPE_TIP;
+      }
+      if (!currentMethod.value) {
+        return NO_METHOD_TIP;
+      }
+      return '';
+    });
+
+    function renderErrorTip(errorTip?: string) {
+      if (!errorTip) {
+        return;
+      }
+      return (
+        <>
+          <div></div>
+          <div class="fvf-form-item-error" title={errorTip}>{errorTip}</div>
+        </>
+      );
+    }
+
+    return () => (
+      <div class={bem()}>
+        <div class={bem('header')}>
+          <div class={bem('select-area')}>
+            <div class={bem('field-label')}>{'所属类型'}</div>
+            <div class={bem('field-value')}>{renderMethodTypeSelect()}</div>
+            <div class={bem('field-label')}>{'函数名'}</div>
+            <div class={bem('field-value')}>{renderMethodSelect()}</div>
+            {renderErrorTip(errorTip.value)}
+            {shouldShowParams.value && (
+              <>
+                <div class={bem('field-label')}>{'返回值'}</div>
+                <div class={bem('field-value')}>{renderReturnType()}</div>
+              </>
+            )}
+          </div>
+          {shouldShowParams.value && (
+            <>
+              <div class={bem('params-title')}>{'入参列表'}</div>
+              <div class={bem('divider')}></div>
+            </>
+          )}
+        </div>
+        <div class={bem('params')}>
+          {shouldShowParams.value && (
+            <div class={bem('param-list')}>
+              {currentParameters.value.map(renderParameter)}
+              {renderParamListPlaceholder()}
+            </div>
+          )}
+        </div>
+      </div>
+    );
+  },
+});
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.props.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.props.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2c67a637dcd8b1e4e4d56625edbe5fd481535fe0
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.props.ts
@@ -0,0 +1,21 @@
+import type { ExtractPropTypes, PropType, Ref } from 'vue';
+import { createPropsResolver } from '@farris/ui-vue';
+import methodInvokeExpressSchema from './schema/method-invoke-express.schema.json';
+import type { ValueExpress } from '@farris/flow-devkit/types';
+import type { NodeVariables } from '@farris/flow-devkit/composition';
+
+export const METHOD_INVOKE_EXPRESS_NAME = 'FvfMethodInvokeExpress';
+
+export const methodInvokeExpressProps = {
+    /** 当前值 */
+    modelValue: { type: Object as PropType<ValueExpress>, default: undefined },
+    /** 仅允许选择或输入数组类型 */
+    onlyAllowArrayType: { type: Boolean, default: false },
+
+    nodeVariables: { type: Object as PropType<Ref<NodeVariables[]>> },
+    writableNodeVariables: { type: Object as PropType<Ref<NodeVariables[]>> },
+};
+
+export type MethodInvokeExpressProps = ExtractPropTypes<typeof methodInvokeExpressProps>;
+
+export const propsResolver = createPropsResolver(methodInvokeExpressProps, methodInvokeExpressSchema);
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.scss
new file mode 100644
index 0000000000000000000000000000000000000000..5013bd580f021cae414abdc7f3287fa7035472fe
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/method-invoke-express.scss
@@ -0,0 +1,100 @@
+.fvf-method-invoke-express {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+    box-sizing: border-box;
+    padding-top: 6px;
+    padding-left: 10px;
+
+    &__header {
+        flex: 0 0 auto;
+        min-height: 0;
+        padding-right: 10px;
+    }
+
+    &__params {
+        flex: 1 1 auto;
+        min-height: 0;
+        overflow-y: auto;
+        overflow-x: hidden;
+        padding-right: 10px;
+    }
+
+    &__select-area {
+        display: grid;
+        column-gap: 6px;
+        row-gap: 10px;
+        grid-template-columns: auto minmax(0, 1fr);
+        width: 100%;
+    }
+
+    &__field-label {
+        align-self: center;
+        text-align: right;
+        white-space: nowrap;
+        font-size: 14px;
+        line-height: 20px;
+    }
+
+    &__params-title {
+        margin-top: 20px;
+        font-size: 14px;
+        line-height: 20px;
+        font-weight: 600;
+    }
+
+    &__divider {
+        display: block;
+        height: 1px;
+        background-color: #e8e8e8;
+        margin-top: 4px;
+        margin-bottom: 8px;
+    }
+
+    &__param-list {
+        display: block;
+    }
+
+    &__param-item {
+        &-header {
+            display: flex;
+            align-items: center;
+            overflow: hidden;
+            gap: 8px;
+        }
+
+        &-label {
+            font-size: 14px;
+            line-height: 20px;
+        }
+
+        &-editor {
+            margin-top: 6px;
+        }
+
+        & + & {
+            margin-top: 12px;
+        }
+    }
+
+    &__no-param {
+        margin-top: 4px;
+        font-size: 13px;
+        line-height: 20px;
+        color: #bbbbbb;
+        user-select: none;
+    }
+
+    &__type {
+        display: inline-block;
+        height: 20px;
+        line-height: 20px;
+        font-size: 12px;
+        color: rgba(15, 21, 40, 0.82);
+        background-color: rgba(87, 104, 161, 0.08);
+        padding: 0 4px;
+        border-radius: 4px;
+        user-select: none;
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/schema/method-invoke-express.schema.json b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/schema/method-invoke-express.schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..c864873dacc8c71ec2415e9df2eb7bb119bd2518
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/method-invoke-express/src/schema/method-invoke-express.schema.json
@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://farris-design.gitee.io/fvf-method-invoke-express.schema.json",
+  "title": "fvf-method-invoke-express",
+  "description": "A Farris Component",
+  "type": "object",
+  "properties": {
+    "id": {
+      "description": "id",
+      "type": "string"
+    },
+    "type": {
+      "description": "type",
+      "type": "string",
+      "default": "fvf-method-invoke-express"
+    },
+    "onlyAllowArrayType": {
+      "description": "onlyAllowArrayType",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": ["id", "type"]
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/param-tag-list/src/param-tag-list.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/param-tag-list/src/param-tag-list.scss
index 25af9229286029b6093661b94b4681ad7a0072e9..0c4cc3da4ee090dbdeeebb6a7fe974080d049cdc 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/param-tag-list/src/param-tag-list.scss
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/param-tag-list/src/param-tag-list.scss
@@ -1,18 +1,26 @@
+@mixin node-field-empty() {
+    display: block;
+    font-style: normal;
+    font-size: 14px;
+    height: 26px;
+    line-height: 26px;
+    color: rgba(6, 7, 9, 0.3);
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+}
+
+.fvf-node-field-empty {
+    @include node-field-empty();
+}
+
 .fvf-param-tag-list {
     display: flex;
     overflow: hidden;
     flex-wrap: nowrap;
 
     &__empty {
-        display: block;
-        font-style: normal;
-        font-size: 14px;
-        height: 26px;
-        line-height: 26px;
-        color: rgba(6, 7, 9, 0.3);
-        overflow: hidden;
-        white-space: nowrap;
-        text-overflow: ellipsis;
+        @include node-field-empty();
     }
 
     &__item {
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/type-selector/src/type-selector.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/type-selector/src/type-selector.component.tsx
index e69e8f4b0106a1d290470d614312e06353156ebe..e9e4c1982c7c73853b2ae96919c1403817e81597 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/type-selector/src/type-selector.component.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/type-selector/src/type-selector.component.tsx
@@ -87,6 +87,9 @@ export default defineComponent({
         }}
         panelBottomContent={renderPanelBottomContent}
         valueDisplay={renderCurrentValue}
+        {...{
+          title: currentValueName.value,
+        }}
         onChange={onChange}
       ></TSelect>
     );
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/index.ts b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/index.ts
index 083c34a9e0469a1d8432f11984df363f86b681ae..f4d4ef3136aaaeeb1217fea8b5e160e640d14565 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/index.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/components/index.ts
@@ -1,2 +1 @@
-export { default as MethodTypeSelect } from './method-type-select';
 export { default as JsonEditor } from './json-editor';
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-const-tab.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-const-tab.tsx
index ad44a340daeede46b4ce841fbe527dc565faa25b..f5b8f3190dbda878131cc663386ca5daab0a1e22 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-const-tab.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-const-tab.tsx
@@ -7,12 +7,12 @@ import type {
   NumberConstExpr,
   BoolConstExpr,
   StringsConstExpr,
+  ValueExpressionResult,
 } from '@farris/flow-devkit/types';
 import { ValueExpressKind, BasicTypeRefer } from '@farris/flow-devkit/types';
 import { ValueExpressUtils, ParameterUtils } from '@farris/flow-devkit/utils';
 import { useBem } from '@farris/flow-devkit/utils';
 import { JsonEditor } from '../components';
-import type { GetValueResult } from './types';
 
 export function useConstTab(props: ValueExpressionInputProps) {
   const onlyAllowArrayType = props.onlyAllowArrayType;
@@ -49,7 +49,7 @@ export function useConstTab(props: ValueExpressionInputProps) {
     },
   }
 
-  function getConstExpr(): GetValueResult | string {
+  function getConstExpr(): ValueExpressionResult {
     switch (inputType.value) {
       case 'string':
         return {
@@ -82,7 +82,7 @@ export function useConstTab(props: ValueExpressionInputProps) {
         type: BasicTypeRefer.StringArrayType,
       };
     } catch {
-      return '请输入合法的字符串集合';
+      return { errorTip: '请输入合法的字符串集合' };
     }
   }
 
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-method-invoke-tab.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-method-invoke-tab.tsx
index 926563c7a6566f2532fa3f1b40ae4a5d3c0f9a8f..98be7f2adcb9077ee8f17d147907dcb1268f6544 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-method-invoke-tab.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-method-invoke-tab.tsx
@@ -1,274 +1,48 @@
-import { ref, computed, watch } from 'vue';
-import { useMethodTypes } from '@farris/flow-devkit/hooks';
-import { useBem, ValueExpressUtils } from '@farris/flow-devkit/utils';
-import { VALUE_EXPRESSION_INPUT_NAME } from '../value-expression-input.props';
-import { MethodTypeSelect } from '../components';
-import { TSelect } from "@farris/flow-devkit/third-party";
-import type { ValueExpress, TypeRefer, MethodInvokeExpr, Type, TypeMethod, Parameter, MethodParameter } from '@farris/flow-devkit/types';
-import { ValueExpressKind } from '@farris/flow-devkit/types';
+import { ref } from 'vue';
 import type { ValueExpressionInputProps } from '../value-expression-input.props';
-import ValueExpressionInput from '../value-expression-input.component';
-import { getNodeVariables, getWritableNodeVariables, useTypeDetails } from '@farris/flow-devkit/composition';
-import type { GetValueResult } from './types';
+import { MethodInvokeExpress } from '@farris/flow-devkit/form-materials/method-invoke-express';
+import type { ValueExpress, ValueExpressionResult } from '@farris/flow-devkit/types';
+import { getNodeVariables, getWritableNodeVariables } from '@farris/flow-devkit/composition';
 
 export function useMethodInvokeTab(props: ValueExpressionInputProps) {
 
-  const onlyAllowArrayType = props.onlyAllowArrayType;
-
-  const { bem } = useBem(VALUE_EXPRESSION_INPUT_NAME);
-  const { mergedMethodTypes, refreshMethodTypes } = useMethodTypes();
-
-  const currentTypeRefer = ref<TypeRefer>();
-  const currentMethodCode = ref<string>();
-  const paramValues = ref<Record<string, ValueExpress>>({});
+  const express = ref<ValueExpress>();
+  const result = ref<ValueExpressionResult>();
+  const methodInvokeExpressInstance = ref();
 
   const nodeVariables = props.nodeVariables ? props.nodeVariables : getNodeVariables();
   const writableNodeVariables = props.writableNodeVariables ? props.writableNodeVariables : getWritableNodeVariables();
-  const {
-    getTypeCode,
-    getTypeName,
-    loadType,
-    isListType,
-  } = useTypeDetails();
-
-  const currentMethodType = computed<Type | undefined>(() => {
-    const typeRefer = currentTypeRefer.value;
-    if (!typeRefer) {
-      return;
-    }
-    return mergedMethodTypes.value.find((type) => {
-      return type.source === typeRefer.source && type.typeId === typeRefer.typeId;
-    });
-  });
-
-  const currentMethods = computed<TypeMethod[]>(() => {
-    return currentMethodType.value?.methods || [];
-  });
-
-  const methodOptions = computed(() => {
-    return currentMethods.value.map((method) => ({
-      label: method.name || method.code,
-      value: method.code,
-    }));
-  });
-
-  const currentMethod = computed<TypeMethod | undefined>(() => {
-    return currentMethods.value.find((method) => {
-      return method.code === currentMethodCode.value;
-    });
-  });
-
-  const currentParameters = computed<Parameter[]>(() => {
-    return currentMethod.value?.parameters || [];
-  });
-
-  const shouldShowParams = computed<boolean>(() => !!currentMethod.value);
-
-  function onUpdateMethodType(typeRefer: TypeRefer, methodCode?: string): void {
-    currentTypeRefer.value = typeRefer;
-    currentMethodCode.value = undefined;
-    if (methodCode) {
-      currentMethodCode.value = methodCode;
-    }
-  }
-
-  function onMethodSelectChange(newValue: any): void {
-    currentMethodCode.value = newValue;
-  }
-
-  function initMethodInvokeTab(): void {
-    refreshMethodTypes();
-  }
-
-  function initParamValues(): void {
-    paramValues.value = {};
-  }
-
-  function loadAllTypes(): void {
-    const method = currentMethod.value;
-    if (!method) {
-      return;
-    }
-    const typeRefers: TypeRefer[] = [];
-    if (method.returnType) {
-      typeRefers.push(method.returnType);
-    }
-    (method.parameters || []).forEach(param => {
-      if (param?.type) {
-        typeRefers.push(param.type);
-      }
-    });
-    if (typeRefers.length) {
-      loadType(typeRefers);
-    }
-  }
-
-  watch(currentMethod, (newValue, oldValue) => {
-    if (!oldValue) {
-      return;
-    }
-    if (newValue?.code !== oldValue.code) {
-      initParamValues();
-    }
-  });
-  watch(currentMethod, loadAllTypes, { immediate: true });
 
   function updateMethodInvokeTab(currentValue?: ValueExpress): void {
-    if (currentValue?.kind !== ValueExpressKind.methodInvoke) {
-      return;
-    }
-    const express = currentValue as MethodInvokeExpr;
-    if (!express.typeUrl) {
-      return;
-    }
-    currentTypeRefer.value = {
-      source: 'default',
-      typeId: express.typeUrl,
-    };
-    currentMethodCode.value = express.methodCode;
-    const params: Record<string, ValueExpress> = {};
-    (express.parameters || []).forEach((param) => {
-      if (param && param.code && param.value) {
-        params[param.code] = param.value;
-      }
-    });
-    paramValues.value = params;
-  }
-
-  function renderParameter(param: Parameter) {
-    const keyID = `${currentMethodType.value!.typeId}_${currentMethod.value!.code}_${param.code}`;
-    const paramName = param.name || param.code;
-    const paramCode = param.code;
-    const paramTitle = `${paramName} - ${paramCode}`;
-    const typeCode = getTypeCode(param.type);
-    const typeName = getTypeName(param.type);
-    return (
-      <div class={bem('method-param-item')} key={keyID}>
-        <div class={bem('method-param-item-header')}>
-          <div class={bem('method-param-item-label')} title={paramTitle}>{param.name || param.code}</div>
-          {typeCode && (
-            <div class={bem('method-type')} title={typeName}>{typeCode}</div>
-          )}
-        </div>
-        <div class={bem('method-param-item-editor')}>
-          <ValueExpressionInput
-            modelValue={paramValues.value[param.code]}
-            nodeVariables={nodeVariables}
-            writableNodeVariables={writableNodeVariables}
-            onUpdate:modelValue={(newValue) => { paramValues.value[param.code] = newValue }}
-          />
-        </div>
-      </div>
-    );
-  }
-
-  function renderMethodTypeSelect() {
-    return (
-      <MethodTypeSelect
-        value={currentTypeRefer.value}
-        onUpdate:value={onUpdateMethodType}
-      />
-    );
+    express.value = currentValue;
   }
 
-  function renderMethodSelect() {
-    return (
-      <TSelect
-        value={currentMethodCode.value}
-        options={methodOptions.value}
-        clearable={false}
-        size={'small'}
-        placeholder={currentMethodType.value ? '请选择方法' : '请先选择类型'}
-        onChange={onMethodSelectChange}
-      />
-    );
-  }
-
-  function renderReturnType() {
-    const returnType = currentMethod.value!.returnType;
-    const typeCode = getTypeCode(returnType) || '无';
-    const typeName = getTypeName(returnType);
-    return (
-      <div class={bem('method-type')} title={typeName}>{typeCode}</div>
-    );
+  function getMethodInvokeExpr(): ValueExpressionResult {
+    if (!result.value) {
+      result.value = methodInvokeExpressInstance.value.getNewValue();
+    }
+    return result.value!;
   }
 
-  function renderParamListPlaceholder() {
-    if (currentParameters.value.length) {
-      return;
-    }
-    return (
-      <div class={bem('method-no-param')}>{'参数列表为空'}</div>
-    );
+  function onChange(_newValue: any, _: any, valueExpressionResult: ValueExpressionResult): void {
+    express.value = valueExpressionResult.express;
+    result.value = valueExpressionResult;
   }
 
   function renderMethodInvokeTab() {
     return (
-      <div class={bem('method-tab')}>
-        <div class={bem('method-tab-header')}>
-          <div class={bem('method-select-area')}>
-            <div class={bem('method-field-label')}>{'所属类型'}</div>
-            <div class={bem('method-field-value')}>{renderMethodTypeSelect()}</div>
-            <div class={bem('method-field-label')}>{'方法名'}</div>
-            <div class={bem('method-field-value')}>{renderMethodSelect()}</div>
-            {shouldShowParams.value && (
-              <>
-                <div class={bem('method-field-label')}>{'返回值'}</div>
-                <div class={bem('method-field-value')}>{renderReturnType()}</div>
-              </>
-            )}
-          </div>
-          {shouldShowParams.value && (
-            <>
-              <div class={bem('method-params-title')}>{'入参列表'}</div>
-              <div class={bem('method-divider')}></div>
-            </>
-          )}
-        </div>
-        <div class={bem('method-tab-params')}>
-          {shouldShowParams.value && (
-            <div class={bem('method-param-list')}>
-              {currentParameters.value.map(renderParameter)}
-              {renderParamListPlaceholder()}
-            </div>
-          )}
-        </div>
-      </div>
-    );
-  }
-
-  function getMethodInvokeExpr(): GetValueResult | string {
-    const method = currentMethod.value;
-    if (!method) {
-      return '请选择一个方法';
-    }
-    const returnType = method.returnType;
-    if (onlyAllowArrayType && !isListType(returnType)) {
-      return '只能选择返回值为数组的方法';
-    }
-    const methodParams: MethodParameter[] = [];
-    currentParameters.value.forEach((param) => {
-      const paramValue = paramValues.value[param.code];
-      if (paramValue) {
-        methodParams.push({
-          code: param.code,
-          value: paramValue,
-        });
-      }
-    });
-    const express = ValueExpressUtils.createMethodInvokeExpr(
-      currentMethodType.value!.typeId,
-      method.code,
-      methodParams,
+      <MethodInvokeExpress
+        ref={methodInvokeExpressInstance}
+        modelValue={express.value}
+        onlyAllowArrayType={props.onlyAllowArrayType}
+        nodeVariables={nodeVariables}
+        writableNodeVariables={writableNodeVariables}
+        onUpdate:modelValue={onChange}
+      />
     );
-    return {
-      express,
-      type: returnType,
-    };
   }
 
   return {
-    initMethodInvokeTab,
     updateMethodInvokeTab,
     getMethodInvokeExpr,
     renderMethodInvokeTab,
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-modal.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-modal.tsx
index d655e97396d4156bdec4b3df89b3922d1ee7b23d..6b86ade458e77074688bf1216a5bd56edfb4a134 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-modal.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-modal.tsx
@@ -1,12 +1,11 @@
 import { inject, ref, type SetupContext } from 'vue';
 import { F_MODAL_SERVICE_TOKEN } from '@farris/ui-vue';
-import { type ValueExpress, ValueExpressKind } from '@farris/flow-devkit/types';
+import { type ValueExpress, type ValueExpressionResult, ValueExpressKind } from '@farris/flow-devkit/types';
 import { type ValueExpressionInputProps, VALUE_EXPRESSION_INPUT_NAME } from '../value-expression-input.props';
 import { useBem } from '@farris/flow-devkit/utils';
 import { useVarTab } from './use-var-tab';
 import { useConstTab } from './use-const-tab';
 import { useMethodInvokeTab } from './use-method-invoke-tab';
-import type { GetValueResult } from './types';
 import { useTypeDetails, useNotify } from '@farris/flow-devkit/composition';
 
 export function useModal(
@@ -38,7 +37,6 @@ export function useModal(
   } = useConstTab(props);
   const {
     renderMethodInvokeTab,
-    initMethodInvokeTab,
     updateMethodInvokeTab,
     getMethodInvokeExpr,
   } = useMethodInvokeTab(props);
@@ -72,15 +70,17 @@ export function useModal(
 
   const { loadType } = useTypeDetails();
 
-  function updateValueAndCloseModal(result: GetValueResult): void {
+  function updateValueAndCloseModal(result: ValueExpressionResult): void {
     const { express, type } = result;
-    loadType(type);
+    if (type) {
+      loadType(type);
+    }
     context.emit('update:modelValue', express, express, result);
     closeModal();
   }
 
   function acceptCallback() {
-    let getNewValue: () => (GetValueResult | string);
+    let getNewValue: () => ValueExpressionResult;
     switch (activeTabId.value) {
       case TAB_NODE_VARIABLE: {
         getNewValue = getNodeVariableExpr;
@@ -95,8 +95,8 @@ export function useModal(
       }
     }
     const result = getNewValue();
-    if (typeof result === 'string') {
-      notifyService.warning(result);
+    if (result.errorTip && typeof result.errorTip === 'string') {
+      notifyService.warning(result.errorTip);
       return;
     }
     updateValueAndCloseModal(result);
@@ -162,7 +162,6 @@ export function useModal(
 
   function beforeOpenModal(): void {
     updateTabData();
-    initMethodInvokeTab();
   }
 
   function openModal() {
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-value-expression.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-value-expression.tsx
index cd92cde4805243d0bcb7c01a72ecfd07c672c6c3..7882b9341445b3d7cb55f2cae9b20bb73673a581 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-value-expression.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-value-expression.tsx
@@ -1,10 +1,10 @@
 import type { Ref } from 'vue';
-import type { ValueExpress, NodeVariableExpr, SystemVariableExpr, Parameter, MethodInvokeExpr } from '@farris/flow-devkit/types';
+import type { ValueExpress, NodeVariableExpr, SystemVariableExpr, MethodInvokeExpr } from '@farris/flow-devkit/types';
 import { ValueExpressKind } from '@farris/flow-devkit/types';
-import { useBem } from '@farris/flow-devkit/utils';
+import { useBem, ParamValidateUtils } from '@farris/flow-devkit/utils';
 import { getNodeVariables, useFlow } from '@farris/flow-devkit/composition';
 import { VALUE_EXPRESSION_INPUT_NAME } from '../value-expression-input.props';
-import { useTypeDetails, type NodeVariables } from '@farris/flow-devkit/composition';
+import { type NodeVariables } from '@farris/flow-devkit/composition';
 import { useMethodTypes } from '@farris/flow-devkit/hooks';
 
 interface RenderOptions {
@@ -22,22 +22,8 @@ export function useValueExpression(options?: RenderOptions) {
   const { bem } = useBem(VALUE_EXPRESSION_INPUT_NAME);
   const nodeVarsList = options?.nodeVariables ? options.nodeVariables : getNodeVariables();
   const useFlowComposition = useFlow();
-  const { hasNestedFieldPath } = useTypeDetails();
   const { mergedMethodTypes } = useMethodTypes();
 
-  function getTargetParameter(express: NodeVariableExpr, params: Parameter[]): Parameter | undefined {
-    const targetById = params.find((item) => {
-      return item.id === express.variableId && item.id && item.code;
-    });
-    if (targetById) {
-      return targetById;
-    }
-    const targetByCode = params.find((item) => {
-      return item.code === express.variable && item.code;
-    });
-    return targetByCode;
-  }
-
   function getNodeNameByNodeCode(nodeCode: string): string {
     const node = useFlowComposition?.getNodeByCode?.(nodeCode);
     if (!node) {
@@ -52,6 +38,7 @@ export function useValueExpression(options?: RenderOptions) {
     nodeName?: string;
     nodeIcon?: string;
     paramCode?: string;
+    fieldCodes?: string[];
   } {
     const nodeCode = express.nodeCode;
     const nodeVariables = nodeVarsList.value.find(
@@ -62,29 +49,30 @@ export function useValueExpression(options?: RenderOptions) {
       return { isDefined: false, nodeName, paramCode: express.variable };
     }
     const targetNode = nodeVariables.node;
-    const targetParam = getTargetParameter(express, nodeVariables.params || []);
-    const isFieldsValid = hasNestedFieldPath(targetParam?.type, express.fields);
+    const targetParam = ParamValidateUtils.getTargetParameter(express, nodeVariables.params || []);
+    const { isFieldsValid, fields } = ParamValidateUtils.isNodeVariableFieldsValid(express, targetParam);
     const isDefined = !!targetNode && !!targetParam && isFieldsValid;
     if (!isDefined) {
       const nodeName = getNodeNameByNodeCode(nodeCode);
-      return { isDefined, nodeName, paramCode: express.variable };
+      return { isDefined, nodeName, paramCode: express.variable, fieldCodes: fields };
     }
     const nodeName = targetNode.data.name || targetNode.metadata.label || '';
     const nodeIcon = targetNode.metadata.icon || '';
     const paramCode = targetParam.code || '';
-    return { isDefined, nodeName, nodeIcon, paramCode };
+    return { isDefined, nodeName, nodeIcon, paramCode, fieldCodes: fields };
   }
 
-  function getFieldsText(express: NodeVariableExpr): string {
-    if (!express || !express.fields || !express.fields.length) {
+  function getFieldsText(express: NodeVariableExpr, fields?: string[]): string {
+    const fieldCodes = fields || express?.fields;
+    if (!fieldCodes || !fieldCodes.length) {
       return '';
     }
-    return `.${express.fields.join('.')}`;
+    return `.${fieldCodes.join('.')}`;
   }
 
   function renderNodeVariable(express: NodeVariableExpr) {
-    const fields = getFieldsText(express);
-    const { isDefined, nodeName, nodeIcon, paramCode } = getNodeVariableInfo(express);
+    const { isDefined, nodeName, nodeIcon, paramCode, fieldCodes } = getNodeVariableInfo(express);
+    const fields = getFieldsText(express, fieldCodes);
     const undefinedText = '未定义';
 
     if (!isDefined && (!nodeName || !paramCode)) {
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-var-tab.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-var-tab.tsx
index bd5c57c2d07bdef04e07e2c251ba18d229fc9923..c57eca9eeaf241933515fe13116bf3cb8e2ba7aa 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-var-tab.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/use-var-tab.tsx
@@ -1,12 +1,11 @@
 import { computed, ref, watch } from 'vue';
 import { type VisualDataCell } from '@farris/ui-vue';
 import { VALUE_EXPRESSION_INPUT_NAME, type ValueExpressionInputProps } from '../value-expression-input.props';
-import type { FlowNodeInstance, Parameter, TypeField, TypeRefer } from '@farris/flow-devkit/types';
-import { ValueExpressUtils } from '@farris/flow-devkit/utils';
+import type { FlowNodeInstance, Parameter, TypeField, TypeRefer, JsonSchema, ValueExpressionResult } from '@farris/flow-devkit/types';
+import { ValueExpressUtils, JsonSchemaUtils } from '@farris/flow-devkit/utils';
 import { useBem } from '@farris/flow-devkit/utils';
 import { getNodeVariables, getWritableNodeVariables } from '@farris/flow-devkit/composition';
 import { useTypeDetails } from '@farris/flow-devkit/composition';
-import type { GetValueResult } from './types';
 
 interface TreeNodeData {
   /** 所属节点 */
@@ -14,11 +13,17 @@ interface TreeNodeData {
   /** 所属参数 */
   param?: Parameter;
   /** 字段路径 */
-  fields?: TypeField[];
+  fieldPath?: TypeField[];
   /** 目标字段 */
   field?: TypeField;
+  /** schema路径 */
+  schemaPath?: JsonSchema[];
+  /** schema字段 */
+  schema?: JsonSchema;
 }
 
+type TreeNodeDataType = 'Parameter' | 'TypeField' | 'Schema';
+
 interface TreeNode {
   id: string;
   data: TreeNodeData,
@@ -28,10 +33,8 @@ interface TreeNode {
 }
 
 export function useVarTab(props: ValueExpressionInputProps) {
-  const onlyAllowArrayType = props.onlyAllowArrayType;
-  const typeFilter = props.typeFilter;
-
   const { bem } = useBem(VALUE_EXPRESSION_INPUT_NAME);
+
   const nodeVariables = props.nodeVariables ? props.nodeVariables : getNodeVariables();
   const writableNodeVariables = props.writableNodeVariables ? props.writableNodeVariables : getWritableNodeVariables();
   const nodeVarsList = computed(() => props.onlyAllowWritableVariable ? writableNodeVariables.value : nodeVariables.value);
@@ -41,77 +44,169 @@ export function useVarTab(props: ValueExpressionInputProps) {
     getTypeCode,
     getTypeName,
     isListType,
+    getListDepth,
     getListItemType,
     loadType,
+    wrapTypeWithArray,
   } = useTypeDetails();
 
   const selectedTreeNode = ref<TreeNode>();
 
+  function getTypeRefer(data: Parameter | TypeField | JsonSchema): TypeRefer | undefined {
+    if ('type' in data && typeof data.type === 'object') {
+      return data.type;
+    }
+    return JsonSchemaUtils.getTypeRefer(data);
+  }
+
+  function createParameterTreeNode(
+    parentId: string,
+    node: FlowNodeInstance,
+    param: Parameter,
+  ): TreeNode {
+    return {
+      id: `${parentId}_param_${param.id || param.code}`,
+      data: {
+        node,
+        param,
+      },
+      parent: parentId,
+      collapse: true,
+    };
+  }
+
+  function createTypeFieldTreeNode(
+    parentId: string,
+    node: FlowNodeInstance,
+    param: Parameter,
+    field: TypeField,
+    fieldPath: TypeField[],
+  ): TreeNode {
+    return {
+      id: `${parentId}_field_${field.code}`,
+      data: {
+        node,
+        param,
+        fieldPath,
+        field,
+      },
+      parent: parentId,
+      collapse: true,
+    };
+  }
+
+  function createJsonSchemaTreeNode(
+    parentId: string,
+    node: FlowNodeInstance,
+    param: Parameter,
+    schema: JsonSchema,
+    schemaPath: JsonSchema[],
+  ): TreeNode | undefined {
+    if (!schema || !schema.code) {
+      return undefined;
+    }
+    return {
+      id: `${parentId}_schema_${schema.id || schema.code}`,
+      data: {
+        node,
+        param,
+        schemaPath,
+        schema,
+      },
+      parent: parentId,
+      collapse: false,
+    };
+  }
+
+  function isTypeValid(
+    data: Parameter | TypeField | JsonSchema,
+    param: Parameter,
+    path: TypeField[] | JsonSchema[],
+  ): boolean {
+    const typeRefer = getTypeRefer(data);
+    if (typeof props.typeFilter === 'function' && typeRefer) {
+      const result = props.typeFilter(typeRefer);
+      if (!result) {
+        return false;
+      }
+    }
+    if (props.onlyAllowArrayType) {
+      const hasListType = [param, ...path].some((item) => {
+        const itemTypeRefer = getTypeRefer(item);
+        return isListType(itemTypeRefer);
+      });
+      if (!hasListType) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   function generateChildNodes(
     parentId: string,
-    data: Parameter | TypeField,
-    dataType: 'Parameter' | 'TypeField',
+    data: Parameter | TypeField | JsonSchema,
+    dataType: TreeNodeDataType,
     node: FlowNodeInstance,
     param: Parameter,
-    fieldPath: TypeField[] = [],
+    path: TypeField[] | JsonSchema[] = [],
   ): TreeNode[] {
     const nodes: TreeNode[] = [];
-    const typeRefer = 'type' in data ? data.type : undefined;
+    const typeRefer = getTypeRefer(data);
     const currentType = typeRefer ? fullTypeID2Type.get(getFullTypeID(typeRefer)) : undefined;
 
     let currentNode: TreeNode;
     if (dataType === 'Parameter') {
-      const paramData = data as Parameter;
-      currentNode = {
-        id: `${parentId}_param_${paramData.id || paramData.code}`,
-        data: {
-          node,
-          param: paramData,
-          fields: undefined,
-          field: undefined,
-        },
-        parent: parentId,
-        collapse: true,
-      };
+      currentNode = createParameterTreeNode(parentId, node, param);
+    } else if (dataType === 'TypeField') {
+      currentNode = createTypeFieldTreeNode(parentId, node, param, data as TypeField, path as TypeField[]);
     } else {
-      const fieldData = data as TypeField;
-      currentNode = {
-        id: `${parentId}_field_${fieldData.code}`,
-        data: {
-          node,
-          param,
-          fields: fieldPath,
-          field: fieldData,
-        },
-        parent: parentId,
-        collapse: true,
-      };
+      currentNode = createJsonSchemaTreeNode(parentId, node, param, data as JsonSchema, path as JsonSchema[])!;
+    }
+    if (!currentNode) {
+      return [];
     }
 
-    const isValid = (() => {
-      if (typeof typeFilter === 'function' && typeRefer) {
-        return typeFilter(typeRefer);
-      }
-      if (onlyAllowArrayType) {
-        return !!typeRefer && isListType(typeRefer);
-      }
-      return true;
-    })();
+    const isValid = isTypeValid(data, param, path);
+    if (!isValid) {
+      currentNode.disabled = true;
+    }
 
     const childNodes: TreeNode[] = [];
-    const targetType = isListType(typeRefer) ? getListItemType(typeRefer) : currentType;
-    const childFields = targetType?.fields || [];
-    childFields.forEach((field) => {
-      const children = generateChildNodes(
-        currentNode.id,
-        field,
-        'TypeField',
-        node,
-        param,
-        [...fieldPath, field],
-      );
-      childNodes.push(...children);
-    });
+    if (dataType !== 'Schema') {
+      const targetType = isListType(typeRefer) ? getListItemType(typeRefer) : currentType;
+      const childFields = targetType?.fields || [];
+      childFields.forEach((field) => {
+        const children = generateChildNodes(
+          currentNode.id,
+          field,
+          'TypeField',
+          node,
+          param,
+          [...(path as TypeField[]), field],
+        );
+        childNodes.push(...children);
+      });
+    }
+    if (dataType === 'Parameter' || dataType === 'Schema') {
+      const currentSchema = dataType === 'Schema' ? data as JsonSchema : param.schema;
+      const objectProperties = JsonSchemaUtils.getObjectProperties(currentSchema);
+      if (Array.isArray(objectProperties)) {
+        objectProperties.forEach((property) => {
+          const children = generateChildNodes(
+            currentNode.id,
+            property,
+            'Schema',
+            node,
+            param,
+            [...(path as JsonSchema[]), property],
+          );
+          childNodes.push(...children);
+          if (children.length) {
+            currentNode.collapse = false;
+          }
+        });
+      }
+    }
 
     if (isValid || childNodes.length > 0) {
       nodes.push(currentNode);
@@ -163,7 +258,7 @@ export function useVarTab(props: ValueExpressionInputProps) {
           data: {
             node,
             param: undefined,
-            fields: undefined,
+            fieldPath: undefined,
             field: undefined,
           },
           parent: '',
@@ -202,12 +297,34 @@ export function useVarTab(props: ValueExpressionInputProps) {
     );
   }
 
-  function renderParamRow(data: TreeNodeData) {
+  function getNodeTitle(data: TreeNodeData): string {
     const param = data.param!;
-    const field = data.field;
-    const nodeTitle = field ? field.code : (param.name || param.code);
-    const nodeSubTitle = field ? field.name : '';
-    const typeRefer = field ? field.type : param.type;
+    if (data.schema) {
+      return data.schema.code;
+    }
+    if (data.field) {
+      return data.field.code;
+    }
+    return (param.name || '').trim() || param.code;
+  }
+
+  function getNodeSubTitle(data: TreeNodeData): string | undefined {
+    if (data.field) {
+      return data.field.name;
+    }
+  }
+
+  function getNodeTypeRefer(data: TreeNodeData): TypeRefer | undefined {
+    if (data.schema) {
+      return JsonSchemaUtils.getTypeRefer(data.schema);
+    }
+    return data.field ? data.field.type : data.param!.type;
+  }
+
+  function renderParamRow(data: TreeNodeData) {
+    const nodeTitle = getNodeTitle(data);
+    const nodeSubTitle = getNodeSubTitle(data);
+    const typeRefer = getNodeTypeRefer(data);
     const typeCode = getTypeCode(typeRefer);
     const typeName = getTypeName(typeRefer);
     return (
@@ -258,50 +375,33 @@ export function useVarTab(props: ValueExpressionInputProps) {
     );
   }
 
-  function wrapTypeWithArray(itemType: TypeRefer, count: number): TypeRefer {
-    let wrappedType = itemType;
-    while (count > 0) {
-      --count;
-      wrappedType = {
-        source: 'default',
-        typeId: 'list',
-        typeCode: `Array<${wrappedType.typeCode || wrappedType.typeId}>`,
-        typeName: `Array<${wrappedType.typeName || wrappedType.typeCode || wrappedType.typeId}>`,
-        genericTypes: [wrappedType],
-      };
+  function getNewType(nodeData: TreeNodeData): TypeRefer {
+    const { param, fieldPath, schemaPath } = nodeData;
+    if (!fieldPath && !schemaPath) {
+      return param!.type;
     }
-    return wrappedType;
-  }
-
-  function getNewType(param: Parameter, fields?: TypeField[]): TypeRefer {
-    if (!fields || !fields.length) {
-      return param.type;
-    }
-    const itemType = fields[fields.length - 1].type;
-    const parentTypes = [
-      param.type,
-      ...fields.slice(0, -1).map(field => field.type),
-    ];
+    const pathTypes = (fieldPath || schemaPath)!.map((item) => getTypeRefer(item)).filter(type => !!type);
+    const itemType = pathTypes[pathTypes.length - 1];
+    const parentTypes = [param!.type, ...pathTypes.slice(0, -1)];
     let listParentCount = 0;
     parentTypes.forEach(parentType => {
-      if (isListType(parentType)) {
-        ++listParentCount;
-      }
+      listParentCount += getListDepth(parentType);
     });
     return wrapTypeWithArray(itemType, listParentCount);
   }
 
-  function getNodeVariableExpr(): GetValueResult | string {
+  function getNodeVariableExpr(): ValueExpressionResult {
     if (!selectedTreeNode.value || !selectedTreeNode.value.data.param) {
-      return '请选择一个节点变量';
+      return { errorTip: '请选择一个节点变量' };
     }
     const data = selectedTreeNode.value.data;
     const param = data.param!;
     const node = data.node!;
-    const fields = (data.fields || []).map(field => (field.code || ''));
-    const type = getNewType(param, data.fields);
+    const fields = (data.fieldPath || data.schemaPath || []).map(field => (field.code || ''));
+    const fieldIds = (data.schemaPath || []).map(field => (field.id || ''));
+    const type = getNewType(data);
     return {
-      express: ValueExpressUtils.createNodeVariableExpr(param, node, fields),
+      express: ValueExpressUtils.createNodeVariableExpr(param, node, fields, fieldIds),
       type,
     };
   }
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/schema/value-expression-input.schema.json b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/schema/value-expression-input.schema.json
index d73e3ac3b7215e50b3f4d28433b575d3ba8ff65a..98f96a0ab956f73d97246a36c37088c8e8670107 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/schema/value-expression-input.schema.json
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/schema/value-expression-input.schema.json
@@ -39,7 +39,7 @@
     },
     "typeFilter": {
       "description": "typeFilter",
-      "type": "function"
+      "type": "object"
     },
     "validateOptions": {
       "description": "validateOptions",
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.component.tsx b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.component.tsx
index 6516247ff182dbaec4f96ce120a1a842904263c2..ed0bf4249e1075cfd8a073cd2d3885bc8c19bdd9 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.component.tsx
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.component.tsx
@@ -3,48 +3,44 @@ import { valueExpressionInputProps, VALUE_EXPRESSION_INPUT_NAME } from './value-
 import { useBem, ParamValidateUtils } from '@farris/flow-devkit/utils';
 import { useModal } from './composition/use-modal';
 import { useValueExpression } from './composition/use-value-expression';
-import type { ValueExpress } from '@farris/flow-devkit/types';
-import type { GetValueResult } from './composition/types';
+import type { ValueExpress, ValueExpressionResult } from '@farris/flow-devkit/types';
 
 import './value-expression-input.scss';
 
 /**
- * 解析 modelValue，支持字符串反序列化和对象格式
+ * 支持字符串反序列化和对象格式
  */
 function parseModelValue(modelValue: ValueExpress | string | undefined): ValueExpress | undefined {
-    if (!modelValue) {
-        return undefined;
-    }
-
-    // 如果已经是对象格式，直接返回
-    if (typeof modelValue === 'object' && modelValue !== null) {
-        return modelValue;
-    }
-
-    // 如果是字符串格式，尝试反序列化
-    if (typeof modelValue === 'string') {
-        try {
-            const parsed = JSON.parse(modelValue);
-            // 确保解析后的对象有 kind 属性
-            if (parsed && typeof parsed === 'object' && parsed.kind) {
-                return parsed;
-            }
-            console.warn('ValueExpressionInput: Invalid serialized ValueExpress format', modelValue);
-            return undefined;
-        } catch (error) {
-            console.warn('ValueExpressionInput: Failed to parse modelValue as JSON', modelValue, error);
-            return undefined;
-        }
-    }
-
+  if (!modelValue) {
     return undefined;
+  }
+  // 如果已经是对象格式，直接返回
+  if (typeof modelValue === 'object' && modelValue !== null) {
+    return modelValue;
+  }
+  // 如果是字符串格式，尝试反序列化
+  if (typeof modelValue === 'string') {
+    try {
+      const parsed = JSON.parse(modelValue);
+      // 确保解析后的对象有 kind 属性
+      if (parsed && typeof parsed === 'object' && parsed.kind) {
+        return parsed;
+      }
+      console.warn('ValueExpressionInput: Invalid serialized ValueExpress format', modelValue);
+      return undefined;
+    } catch (error) {
+      console.warn('ValueExpressionInput: Failed to parse modelValue as JSON', modelValue, error);
+      return undefined;
+    }
+  }
+  return undefined;
 }
 
 export default defineComponent({
   name: VALUE_EXPRESSION_INPUT_NAME,
   props: valueExpressionInputProps,
   emits: {
-    'update:modelValue': (_express: ValueExpress, _: ValueExpress, _result: GetValueResult) => {
+    'update:modelValue': (_express: ValueExpress, _: ValueExpress, _result: ValueExpressionResult) => {
       return true;
     }
   },
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.scss b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.scss
index b6e3e9a0ac5e0bc9b86ee3baef5a93ed9f047cf5..694514f77c55b364c17bde1cfc3f5991b8747c66 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.scss
+++ b/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/value-expression-input.scss
@@ -278,107 +278,4 @@
         height: 100%;
         overflow: hidden;
     }
-
-    &__method {
-        &-tab {
-            display: flex;
-            flex-direction: column;
-            height: 100%;
-            overflow: hidden;
-            box-sizing: border-box;
-            padding-top: 6px;
-            padding-left: 10px;
-
-            &-header {
-                flex: 0 0 auto;
-                min-height: 0;
-                padding-right: 10px;
-            }
-
-            &-params {
-                flex: 1 1 0;
-                min-height: 0;
-                overflow-y: auto;
-                overflow-x: hidden;
-                padding-right: 10px;
-            }
-        }
-
-        &-select-area {
-            display: grid;
-            column-gap: 6px;
-            row-gap: 10px;
-            grid-template-columns: auto minmax(0, 1fr);
-            width: 100%;
-        }
-
-        &-field-label {
-            align-self: center;
-            text-align: right;
-            white-space: nowrap;
-            font-size: 14px;
-            line-height: 20px;
-        }
-
-        &-params-title {
-            margin-top: 20px;
-            font-size: 14px;
-            line-height: 20px;
-            font-weight: 600;
-        }
-
-        &-divider {
-            display: block;
-            height: 1px;
-            background-color: #e8e8e8;
-            margin-top: 4px;
-            margin-bottom: 8px;
-        }
-
-        &-param-list {
-            display: block;
-        }
-
-        &-param-item {
-            &-header {
-                display: flex;
-                align-items: center;
-                overflow: hidden;
-                gap: 8px;
-            }
-
-            &-label {
-                font-size: 14px;
-                line-height: 20px;
-            }
-
-            &-editor {
-                margin-top: 6px;
-            }
-
-            & + & {
-                margin-top: 12px;
-            }
-        }
-
-        &-no-param {
-            margin-top: 4px;
-            font-size: 13px;
-            line-height: 20px;
-            color: #bbbbbb;
-            user-select: none;
-        }
-
-        &-type {
-            display: inline-block;
-            height: 20px;
-            line-height: 20px;
-            font-size: 12px;
-            color: rgba(15, 21, 40, 0.82);
-            background-color: rgba(87, 104, 161, 0.08);
-            padding: 0 4px;
-            border-radius: 4px;
-            user-select: none;
-        }
-    }
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/index.ts b/ai-flow-front/packages/flow-devkit/lib/index.ts
index 1a974ccb77878f01b8d09ed667292ce742889df1..3447f0bdd44f1a03ee54bb976cba87f700676e91 100644
--- a/ai-flow-front/packages/flow-devkit/lib/index.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/index.ts
@@ -12,3 +12,5 @@ export * from './utils/uuid';
 export * from './utils/value-express';
 export * from './utils/param-validate';
 export * from './utils/validate';
+export * from './utils/json-schema';
+export * from './hooks/use-method-types';
diff --git a/ai-flow-front/packages/flow-devkit/lib/third-party/tdesign-exports.ts b/ai-flow-front/packages/flow-devkit/lib/third-party/tdesign-exports.ts
index c0441cdd99b73f6ca5c8228207e037bc1f3ba57a..ecc658a062d011969cdc5ea2ca10be2fb8da9305 100644
--- a/ai-flow-front/packages/flow-devkit/lib/third-party/tdesign-exports.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/third-party/tdesign-exports.ts
@@ -1,10 +1,26 @@
 import 'tdesign-vue-next/es/style/index.css';
 
 export { Popup as TPopup } from 'tdesign-vue-next';
-export type { PopupProps as TPopupProps } from 'tdesign-vue-next';
+export type {
+    PopupProps as TPopupProps,
+} from 'tdesign-vue-next';
 
 export { SelectInput as TSelectInput } from 'tdesign-vue-next';
-export type { SelectInputProps as TSelectInputProps } from 'tdesign-vue-next';
+export type {
+    SelectInputProps as TSelectInputProps,
+} from 'tdesign-vue-next';
 
 export { Select as TSelect } from 'tdesign-vue-next';
-export type { SelectProps as TSelectProps } from 'tdesign-vue-next';
+export type {
+    SelectProps as TSelectProps,
+    SelectOption as TSelectOption,
+    TdOptionProps,
+} from 'tdesign-vue-next';
+
+export { Tree as TTree } from 'tdesign-vue-next';
+export type {
+    TreeProps as TTreeProps,
+    TreeOptionData as TTreeNodeData,
+    TreeNodeModel as TTreeNodeModel,
+    TreeNodeValue as TTreeNodeValue,
+} from 'tdesign-vue-next';
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/builtin-node-type.ts b/ai-flow-front/packages/flow-devkit/lib/types/builtin-node-type.ts
index 4b0341f8656aa623ca4725200d6ad8bf53e69328..4a851d378eeb5c1dcb91c180d5da40bda000b56c 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/builtin-node-type.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/builtin-node-type.ts
@@ -11,4 +11,6 @@ export enum BuiltinNodeType {
     VariableDef = 'variableDef',
     /** 变量赋值节点 */
     VariableAssign = 'batchAssignValue',
+    /** 函数调用节点 */
+    MethodInvoke = 'methodInvoke',
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/types.ts b/ai-flow-front/packages/flow-devkit/lib/types/common.ts
similarity index 40%
rename from ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/types.ts
rename to ai-flow-front/packages/flow-devkit/lib/types/common.ts
index 030401d777f01d799db6541d9b01874541d95aed..d894311e34029d2a882802a718d5207d3fa0ec3c 100644
--- a/ai-flow-front/packages/flow-devkit/lib/form-materials/value-expression-input/src/composition/types.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/common.ts
@@ -1,6 +1,7 @@
 import type { TypeRefer, ValueExpress } from '@farris/flow-devkit/types';
 
-export interface GetValueResult {
-    express: ValueExpress;
-    type: TypeRefer;
+export interface ValueExpressionResult {
+    express?: ValueExpress;
+    type?: TypeRefer;
+    errorTip?: string;
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/flow-metadata.ts b/ai-flow-front/packages/flow-devkit/lib/types/flow-metadata.ts
index 485a5ae26883a163340042832ac7626d90baa888..27970f15f42413c54dca5f7a20c67f57550a1b68 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/flow-metadata.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/flow-metadata.ts
@@ -1,5 +1,7 @@
 import type { SizeSchema } from './node-definition';
 import type { TypeRefer } from './type';
+import type { JsonSchema } from './json-schema';
+import type { InputHelp } from './input-help';
 import type { EdgeComponent, Styles } from '@vue-flow/core';
 
 /** 流程元数据 */
@@ -103,8 +105,8 @@ export interface Parameter {
      */
     code: string;
     /**
-     * 参数名称
-     * @description 后端不存储`name`字段，仅前端内部使用
+     * 显示名称
+     * @description 在`试运行`面板中，如果`显示名称`非空则显示`显示名称`，否则显示`参数编号`
      */
     name?: string;
     /** 参数描述 */
@@ -113,6 +115,8 @@ export interface Parameter {
     type: TypeRefer;
     /** 参数值 */
     valueExpr?: ValueExpress;
+    /** @deprecated 本字段无效，请使用`valueExpr`字段 */
+    value?: any;
     /** 是否必填 */
     required?: boolean;
     /**
@@ -130,6 +134,9 @@ export interface Parameter {
      * @description 当`type`为`Object`或`Array<Object>`时，通过本字段描述`Object`的结构
      */
     schema?: JsonSchema;
+
+    /** 输入帮助设置 */
+    inputHelp?: InputHelp;
 }
 
 export type JsonNode = Record<string, any>;
@@ -149,7 +156,14 @@ export interface ValueExpress {
     [key: string]: any;
 }
 
-export type JsonSchema = any;  // 待定
+/**
+ * 值表达式的类型
+ * @description 根据值表达式`ValueExpress`推断得到的类型信息
+ */
+export interface ValueExpressType {
+    type: TypeRefer;
+    schema?: JsonSchema;
+}
 
 /** 节点的画布信息 */
 export interface NodeGraphMeta {
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/flow-registry.ts b/ai-flow-front/packages/flow-devkit/lib/types/flow-registry.ts
index 7795c28ea8a003d27c5a8b4df91d2798a6a65545..0264185694edd5e25b69e489bd0ae7ce44ee588a 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/flow-registry.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/flow-registry.ts
@@ -89,6 +89,10 @@ export interface FlowRegistry {
     edges?: Record<string, Component<EdgeProps>>;
     /** 获取流程的属性面板配置 */
     getPropertyPanelConfig?: (flowExtensionData: JsonNode) => PropertyPanelConfig;
+    /** 流程属性面板默认宽度，单位`px`，默认`300` */
+    flowPropertyPanelDefaultWidth?: number;
+    /** 节点属性面板默认宽度，单位`px`，默认`450` */
+    nodePropertyPanelDefaultWidth?: number;
     /**
      * 初始化流程数据
      * @description
@@ -106,4 +110,11 @@ export interface FlowRegistry {
      * @description 每次打开设计器时都会调用本方法，设计器会等待本方法执行完毕后再显示画布，你可以通过本方法提前加载一些必要的数据
      */
     onDesignerOpen?: (flowMetadata: FlowMetadata) => Promise<void>;
+    /**
+     * 保存元数据前回调
+     * @description 用于在保存元数据前对元数据进行自定义修改，如果返回`undefined`则放弃保存
+     * @param flowMetadata 流程元数据
+     * @returns 经过修改后的流程元数据
+     */
+    beforeSaveMetadata?: (flowMetadata: FlowMetadata) => FlowMetadata | undefined;
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/index.ts b/ai-flow-front/packages/flow-devkit/lib/types/index.ts
index 29298d181f1137ba4b5f9130a659509cbb758cbd..4e55786be07a96dcfaa73607afc354850c32f7aa 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/index.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/index.ts
@@ -8,3 +8,6 @@ export * from './selector';
 export * from './builtin-node-type';
 export * from './type';
 export * from './validate';
+export * from './json-schema';
+export * from './input-help';
+export * from './common';
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/input-help.ts b/ai-flow-front/packages/flow-devkit/lib/types/input-help.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a9d8563af925721ba752dd42fede2ee1c9b4156c
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/types/input-help.ts
@@ -0,0 +1,27 @@
+/**
+ * 输入帮助设置
+ */
+export interface InputHelp {
+    kind: string;
+}
+
+export const InputHelpKind = {
+    enum: 'enum',
+} as const;
+
+/**
+ * `下拉选项`输入帮助
+ */
+export interface EnumInputHelp extends InputHelp {
+    kind: typeof InputHelpKind.enum;
+
+    /** 可选的枚举值 */
+    items: EnumItem[];
+}
+
+export interface EnumItem {
+    key: string;
+    value: string;
+
+    [key: string]: any;
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/json-schema.ts b/ai-flow-front/packages/flow-devkit/lib/types/json-schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ce8fc15b6eca227a60c5e1de2ff3842747092995
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/types/json-schema.ts
@@ -0,0 +1,24 @@
+export type JsonSchemaType = 'array' | 'object' | 'string' | 'boolean' | 'number';
+
+export enum JsonSchemaBasicType {
+    Array = 'array',
+    Object = 'object',
+    String = 'string',
+    Boolean = 'boolean',
+    Number = 'number',
+}
+
+export interface JsonSchema {
+    /**
+     * 唯一标识
+     * @description 后端不存储`id`字段，仅前端内部使用，创建参数时必须设置`id`属性
+     */
+    id: string;
+
+    type: JsonSchemaType;
+    code: string;
+    name?: string;
+    description?: string;
+    items?: JsonSchema;
+    properties?: JsonSchema[];
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/node-definition.ts b/ai-flow-front/packages/flow-devkit/lib/types/node-definition.ts
index 27509dc36ce914b49ec9e0ffcb73c249d52d68e0..5249276aad50a0e554183d734204095aac5b6bfd 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/node-definition.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/node-definition.ts
@@ -272,18 +272,25 @@ type GetOutputParams = (nodeData: NodeData) => Parameter[];
 export interface NodeDefinition {
   /** 节点元数据 */
   metadata: NodeMetadata;
+
   /** 节点渲染组件 */
   component: Component<NodeProps>;
+
   /** 校验节点数据 */
   validator?: (data: NodeData) => NodeValidationResult;
+
   /**
    * 初始化节点数据
    * @description 在新建节点时将调用本方法初始化节点数据
    */
   initialData?: () => Partial<NodeData>;
+
   /** 获取节点属性面板配置 */
   getPropertyPanelConfig?: (nodeData: NodeData, node: FlowNodeInstance) => PropertyPanelConfig;
 
+  /** 属性面板默认宽度，单位`px`，优先级高于`FlowRegistry.nodePropertyPanelDefaultWidth` */
+  propertyPanelDefaultWidth?: number;
+
   /**
    * 获取供后续节点引用的参数列表
    * @description 开始节点默认使用`inputParams`属性，其它节点默认使用`outputParams`属性
diff --git a/ai-flow-front/packages/flow-devkit/lib/types/value-express.ts b/ai-flow-front/packages/flow-devkit/lib/types/value-express.ts
index 882895c4d96c4a0c1869ceda52c00c83351713d6..26e1336f6b3d5e13e9f33eea107bd40f7162c861 100644
--- a/ai-flow-front/packages/flow-devkit/lib/types/value-express.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/types/value-express.ts
@@ -29,7 +29,7 @@ export interface NodeVariableExpr extends ValueExpress {
      */
     variable: string;
     /**
-     * 字段路径
+     * 字段编号路径
      * @description 如果希望选择一个`Object`类型的变量的子字段，需要通过`fields`表明字段的路径
      */
     fields?: string[];
@@ -39,6 +39,12 @@ export interface NodeVariableExpr extends ValueExpress {
      * @description 后端不存储，仅前端内部使用，与`Parameter.id`对应
      */
     variableId?: string;
+
+    /**
+     * 字段ID路径
+     * @description 后端不存储，仅前端内部使用，与`JsonSchema.id`对应
+     */
+    fieldIds?: string[];
 }
 
 /** 系统变量值表达式 */
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/index.ts b/ai-flow-front/packages/flow-devkit/lib/utils/index.ts
index c6c396d845fbb4bb63009765558ea7b4d0c13f83..3af6143dc65ad6ea9ac768ded45e666e5fd7bd39 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/index.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/index.ts
@@ -5,3 +5,5 @@ export * from './value-express';
 export * from './parameter';
 export * from './param-validate';
 export * from './validate';
+export * from './json-schema';
+export * from './input-help';
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/input-help.ts b/ai-flow-front/packages/flow-devkit/lib/utils/input-help.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0e667fc14d9d387f0ac8a024dfd83b67e8cd715a
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/input-help.ts
@@ -0,0 +1,29 @@
+import {
+    InputHelpKind,
+    BasicTypeRefer,
+    type InputHelp,
+    type EnumInputHelp,
+    type TypeRefer,
+    type EnumItem,
+} from '@farris/flow-devkit/types';
+import { ParameterUtils } from './parameter';
+
+export class InputHelpUtils {
+
+    public static createEnumInputHelp(items: EnumItem[] = []): EnumInputHelp {
+        return {
+            kind: InputHelpKind.enum,
+            items,
+        };
+    }
+
+    public static getInputHelp(newType: TypeRefer): InputHelp | undefined {
+        if (!newType) {
+            return undefined;
+        }
+        if (ParameterUtils.isSame(newType, BasicTypeRefer.StringType)) {
+            return this.createEnumInputHelp();
+        }
+        return undefined;
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/json-schema.ts b/ai-flow-front/packages/flow-devkit/lib/utils/json-schema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6c40bf56a8e5bc39436ccee92ff61892367c5767
--- /dev/null
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/json-schema.ts
@@ -0,0 +1,235 @@
+import type { JsonSchema, JsonSchemaType, TypeRefer } from '@farris/flow-devkit/types';
+import { JsonSchemaBasicType, BasicTypeRefer } from '@farris/flow-devkit/types';
+import { uuid } from './uuid';
+import { ParameterUtils } from './parameter';
+
+export class JsonSchemaUtils {
+
+    public static transSchemaType2SelectorValue(schema: JsonSchema): string {
+        const type = schema.type;
+        if (type !== JsonSchemaBasicType.Array) {
+            return type;
+        }
+        const arrayItemType = schema.items?.type;
+        if (!arrayItemType) {
+            return JsonSchemaBasicType.Array;
+        }
+        return `${JsonSchemaBasicType.Array}-${arrayItemType}`;
+    }
+
+    public static updateSchemaTypeBySelectorValue(schema: JsonSchema, selectorValue: string): void {
+        if (!selectorValue) {
+            return;
+        }
+        const oldProperties = this.getObjectProperties(schema) || [];
+        if (selectorValue === JsonSchemaBasicType.Object) {
+            schema.type = JsonSchemaBasicType.Object;
+            schema.items = undefined;
+            schema.properties = oldProperties;
+            return;
+        }
+        if (selectorValue.startsWith(JsonSchemaBasicType.Array)) {
+            schema.type = JsonSchemaBasicType.Array;
+            schema.properties = undefined;
+            const arrayItemType = selectorValue.split('-')[1] as JsonSchemaType;
+            schema.items = this.createJsonSchemaByType(arrayItemType);
+            if (arrayItemType === JsonSchemaBasicType.Object) {
+                schema.items.properties = oldProperties;
+            }
+            return;
+        }
+        schema.type = selectorValue as JsonSchemaType;
+        schema.items = undefined;
+        schema.properties = undefined;
+        return;
+    }
+
+    private static _createJsonSchemaByType(type: JsonSchemaType): JsonSchema {
+        const schema: JsonSchema = {
+            id: uuid(),
+            code: '',
+            name: '',
+            description: '',
+            type,
+        };
+        if (type === JsonSchemaBasicType.Object) {
+            schema.properties = [];
+        }
+        return schema;
+    }
+
+    public static createJsonSchemaByType(type: JsonSchemaType, arrayItemType: JsonSchemaType = 'string'): JsonSchema {
+        const schema = this._createJsonSchemaByType(type);
+        if (type === JsonSchemaBasicType.Array && arrayItemType) {
+            schema.items = this._createJsonSchemaByType(arrayItemType);
+        }
+        return schema;
+    }
+
+    public static canEditJsonSchema(type: TypeRefer): boolean {
+        return ParameterUtils.isSame(type, BasicTypeRefer.ObjectType) || ParameterUtils.isSame(type, BasicTypeRefer.ObjectArrayType);
+    }
+
+    public static mayHasJsonSchema(type?: TypeRefer): boolean {
+        if (!type) {
+            return false;
+        }
+        if (ParameterUtils.isArray(type)) {
+            return this.mayHasJsonSchema(type.genericTypes?.[0]);
+        }
+        if (ParameterUtils.isSame(type, BasicTypeRefer.ObjectType)) {
+            return true;
+        }
+        return false;
+    }
+
+    public static canAddSubLevel(schema: JsonSchema): boolean {
+        if (!schema) {
+            return false;
+        }
+        return schema.type === JsonSchemaBasicType.Object || (
+            schema.type === JsonSchemaBasicType.Array && schema.items?.type === JsonSchemaBasicType.Object
+        );
+    }
+
+    public static getObjectProperties(schema?: JsonSchema): JsonSchema[] | undefined {
+        if (!schema) {
+            return undefined;
+        }
+        if (schema.type === JsonSchemaBasicType.Object) {
+            return schema.properties;
+        }
+        if (schema.type === JsonSchemaBasicType.Array) {
+            return this.getObjectProperties(schema.items);
+        }
+        return undefined;
+    }
+
+    public static getTypeRefer(schema?: JsonSchema): TypeRefer | undefined {
+        if (!schema || !schema.type) {
+            return undefined;
+        }
+        switch (schema.type) {
+            case JsonSchemaBasicType.String: return BasicTypeRefer.StringType;
+            case JsonSchemaBasicType.Boolean: return BasicTypeRefer.BooleanType;
+            case JsonSchemaBasicType.Number: return BasicTypeRefer.NumberType;
+            case JsonSchemaBasicType.Object: return BasicTypeRefer.ObjectType;
+            case JsonSchemaBasicType.Array: {
+                const itemTypeRefer = this.getTypeRefer(schema.items) ?? BasicTypeRefer.StringType;
+                const typeRefer: TypeRefer = {
+                    source: "default",
+                    typeId: "list",
+                    typeCode: `Array<${itemTypeRefer.typeCode}>`,
+                    typeName: `Array<${itemTypeRefer.typeName}>`,
+                    genericTypes: [itemTypeRefer],
+                };
+                return typeRefer;
+            }
+        }
+        return undefined;
+    }
+
+    public static wrapSchemaWithArray(schema: JsonSchema, count: number): JsonSchema {
+        let wrappedSchema = schema;
+        while (count > 0) {
+            --count;
+            wrappedSchema = {
+                id: uuid(),
+                type: JsonSchemaBasicType.Array,
+                code: '',
+                items: wrappedSchema,
+            };
+        }
+        return wrappedSchema;
+    }
+
+    public static getFieldJsonSchema(schema?: JsonSchema, fieldIds?: string[], arrayDepth = 0): JsonSchema | undefined {
+        if (!schema) {
+            return undefined;
+        }
+        if (!fieldIds || !fieldIds.length) {
+            return this.wrapSchemaWithArray(schema, arrayDepth);
+        }
+        if (schema.type === JsonSchemaBasicType.Array) {
+            return this.getFieldJsonSchema(schema.items, fieldIds, arrayDepth + 1);
+        }
+        if (schema.type === JsonSchemaBasicType.Object) {
+            const currentFieldId = fieldIds[0];
+            const remainingFieldIds = fieldIds.slice(1);
+            const matchedField = schema.properties?.find(
+                property => property.id === currentFieldId && currentFieldId
+            );
+            if (!matchedField) {
+                return undefined;
+            }
+            return this.getFieldJsonSchema(matchedField, remainingFieldIds, arrayDepth);
+        }
+        return undefined;
+    }
+
+    public static getCodePathByIdPath(schema: JsonSchema, fieldIds: string[]): string[] {
+        if (!schema || !fieldIds || !fieldIds.length) {
+            return [];
+        }
+        const fieldCodes: string[] = [];
+        let currentSchema: JsonSchema | undefined = schema;
+        while (fieldCodes.length < fieldIds.length) {
+            const properties = this.getObjectProperties(currentSchema);
+            const fieldId = fieldIds[fieldCodes.length];
+            currentSchema = properties?.find(property => property.id === fieldId && fieldId);
+            if (!currentSchema) {
+                break;
+            }
+            fieldCodes.push(currentSchema.code);
+        }
+        return fieldCodes.length !== fieldIds.length ? [] : fieldCodes;
+    }
+
+    public static getIdPathByCodePath(schema: JsonSchema, fieldCodes: string[]): string[] {
+        if (!schema || !fieldCodes || !fieldCodes.length) {
+            return [];
+        }
+        const fieldIds: string[] = [];
+        let currentSchema: JsonSchema | undefined = schema;
+        while (fieldIds.length < fieldCodes.length) {
+            const properties = this.getObjectProperties(currentSchema);
+            const fieldCode = fieldCodes[fieldIds.length];
+            currentSchema = properties?.find(property => property.code === fieldCode && fieldCode);
+            if (!currentSchema || !currentSchema.id) {
+                break;
+            }
+            fieldIds.push(currentSchema.id);
+        }
+        return fieldIds.length !== fieldCodes.length ? [] : fieldIds;
+    }
+
+    public static getParentObjectSchema(rootSchema?: JsonSchema, targetSchema?: JsonSchema): JsonSchema | undefined {
+        if (!rootSchema || !targetSchema) {
+            return undefined;
+        }
+        const schemas2Scan: JsonSchema[] = [rootSchema];
+        while (schemas2Scan.length) {
+            const currentSchema = schemas2Scan.pop();
+            if (!currentSchema) {
+                continue;
+            }
+            if (
+                currentSchema.type === JsonSchemaBasicType.Array &&
+                currentSchema.items &&
+                currentSchema.items.type === JsonSchemaBasicType.Object
+            ) {
+                schemas2Scan.push(currentSchema.items);
+                continue;
+            }
+            if (currentSchema.type === JsonSchemaBasicType.Object) {
+                const properties = currentSchema.properties || [];
+                const bingo = !!properties?.find(property => property === targetSchema);
+                if (bingo) {
+                    return currentSchema;
+                }
+                schemas2Scan.push(...properties);
+            }
+        }
+        return undefined;
+    }
+}
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/param-validate.ts b/ai-flow-front/packages/flow-devkit/lib/utils/param-validate.ts
index 92a99031bc13eb6ebb432d033fcd4afd6e682918..cec0d7eb7531d734b559ddba3cb64101a8893960 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/param-validate.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/param-validate.ts
@@ -8,6 +8,7 @@ import type {
 import { type NodeVariables, useTypeDetails } from '@farris/flow-devkit/composition';
 import { VARIABLE_NAME_REGEX, NODE_VARIABLES_KEY } from '@farris/flow-devkit/constants';
 import { ValueExpressUtils } from './value-express';
+import { JsonSchemaUtils } from './json-schema';
 
 export class ParamValidateUtils {
 
@@ -31,6 +32,63 @@ export class ParamValidateUtils {
         return undefined;
     }
 
+    private static isSame(arrayA?: any[], arrayB?: any[]): boolean {
+        if (!arrayA && !arrayB) {
+            return true;
+        }
+        if (!arrayA || !arrayB) {
+            return false;
+        }
+        for (let i = 0; i < arrayA.length; i++) {
+            if (arrayA[i] !== arrayB[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static isNodeVariableFieldsValid(value: NodeVariableExpr, param?: Parameter): {
+        isFieldsValid: boolean;
+        fields: string[];
+    } {
+        const fields = value?.fields || [];
+        if (!fields.length) {
+            return { isFieldsValid: true, fields };
+        }
+        if (!param) {
+            return { isFieldsValid: false, fields };
+        }
+        if (!JsonSchemaUtils.mayHasJsonSchema(param.type)) {
+            const { hasNestedFieldPath } = useTypeDetails();
+            const isFieldsValid = hasNestedFieldPath(param.type, fields);
+            return { isFieldsValid, fields };
+        }
+        const fieldIds = value.fieldIds || [];
+        const schema = param.schema!;
+        // 通过ID路径查找当前的编号路径
+        const fieldCodes = JsonSchemaUtils.getCodePathByIdPath(schema, fieldIds);
+        let isValid: boolean = false;
+        if (fieldCodes.length) {
+            // 成功根据ID路径查询到编号路径，更新编号路径
+            if (this.isSame(value.fields, fieldCodes) === false) {  // 避免无限递归更新
+                value.fields = fieldCodes;
+            }
+            isValid = true;
+        } else {
+            // 试图根据编号路径重新确定ID路径
+            const newIdPath = JsonSchemaUtils.getIdPathByCodePath(schema, fields);
+            if (newIdPath.length) {
+                // 重新跟踪成功，更新ID路径
+                value.fieldIds = newIdPath;
+                isValid = true;
+            }
+        }
+        return {
+            isFieldsValid: isValid,
+            fields: fieldCodes.length > 0 ? fieldCodes : fields,
+        };
+    }
+
     public static validateValue(value?: ValueExpress, options?: ParamValueValidateOptions): string | undefined {
         const fieldName = options?.fieldName || '参数值';
         const allowValueEmpty = options?.allowValueEmpty ?? true;
@@ -55,8 +113,7 @@ export class ParamValidateUtils {
         }
         const targetNode = nodeVariables.node;
         const targetParam = this.getTargetParameter(value, nodeVariables.params || []);
-        const { hasNestedFieldPath } = useTypeDetails();
-        const isFieldsValid = hasNestedFieldPath(targetParam?.type, value.fields);
+        const { isFieldsValid } = this.isNodeVariableFieldsValid(value, targetParam);
         const isDefined = !!targetNode && !!targetParam && isFieldsValid;
         if (!isDefined) {
             return nodeVariableUndefinedTip;
@@ -64,16 +121,7 @@ export class ParamValidateUtils {
         return undefined;
     }
 
-    private static getTargetParameter(express: NodeVariableExpr, params: Parameter[]): Parameter | undefined {
-        const targetById = params.find((item) => {
-            return item.id === express.variableId && item.id && item.code;
-        });
-        if (targetById) {
-            return targetById;
-        }
-        const targetByCode = params.find((item) => {
-            return item.code === express.variable && item.code;
-        });
-        return targetByCode;
+    public static getTargetParameter(express: NodeVariableExpr, params: Parameter[]): Parameter | undefined {
+        return ValueExpressUtils.getTargetParameter(express, params);
     }
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/parameter.ts b/ai-flow-front/packages/flow-devkit/lib/utils/parameter.ts
index 5729f5151739dcac8b951b5a6574b34c74632258..095330530e86c88ff3aa1660888fa720da9b6b17 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/parameter.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/parameter.ts
@@ -15,7 +15,7 @@ export class ParameterUtils {
         return ids;
     }
 
-    private static isSame(typeA: TypeRefer, typeB: TypeRefer): boolean {
+    public static isSame(typeA: TypeRefer, typeB: TypeRefer): boolean {
         if (!typeA || !typeB) {
             return false;
         }
@@ -45,4 +45,14 @@ export class ParameterUtils {
         }
         return undefined;
     }
+
+    /** 是否数组类型 */
+    public static isArray(typeRefer?: TypeRefer): boolean {
+        return !!typeRefer && typeRefer.source === 'default' && typeRefer.typeId === 'list';
+    }
+
+    /** 是否空类型 */
+    public static isVoid(typeRefer?: TypeRefer): boolean {
+        return !!typeRefer && typeRefer.source === 'default' && typeRefer.typeId === 'void';
+    }
 }
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/uuid.ts b/ai-flow-front/packages/flow-devkit/lib/utils/uuid.ts
index ab91d802e2b18fae2c58f3912167aa5ee6c7e11d..caeb2d5e73c3d0642975cdefc993f048f23c0362 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/uuid.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/uuid.ts
@@ -14,7 +14,8 @@ export const shortid = (
   const genId = customAlphabet(alphabet, length);
   return `${prefix}${genId()}`;
 };
-// 生成UUID,将中划线替换为下划线
+
+// 生成UUID，将中划线替换为下划线
 export const uuid = () => nanoid().replace(/-/g, '_');
 
 export const id = shortid;
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/validate.ts b/ai-flow-front/packages/flow-devkit/lib/utils/validate.ts
index cc2504d80c316c9670a739c6d7e34786dde4bdc4..0c85d9c02bc7b39d3f9c0a7824b82750f197a910 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/validate.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/validate.ts
@@ -6,8 +6,9 @@ import type {
     ParamValueValidateOptions,
     AssignValueExpr,
     SelectorBranch,
+    JsonSchema,
 } from '@farris/flow-devkit/types';
-import { CompareOperator } from '@farris/flow-devkit/types';
+import { CompareOperator, JsonSchemaBasicType } from '@farris/flow-devkit/types';
 import { ValueExpressUtils } from './value-express';
 import { ParamValidateUtils } from './param-validate';
 
@@ -42,6 +43,27 @@ export class ValidateUtils {
         return { isValid: !!errors.length, errors };
     }
 
+    private static validateJsonSchema(schema?: JsonSchema, options?: ParamValidateOptions): string[] {
+        if (!schema) {
+            return [];
+        }
+        if (schema.type === JsonSchemaBasicType.Array) {
+            return this.validateJsonSchema(schema.items);
+        }
+        if (schema.type === JsonSchemaBasicType.Object && Array.isArray(schema.properties)) {
+            const errors: string[] = [];
+            const allCodes = schema.properties.map((property) => property.code);
+            const getAllCodes = () => allCodes;
+            schema.properties.forEach((property) => {
+                const codeError = ParamValidateUtils.validateCode(property.code, { ...options, getAllCodes });
+                codeError && errors.push(codeError);
+                errors.push(...this.validateJsonSchema(property, options));
+            });
+            return errors;
+        }
+        return [];
+    }
+
     /**
      * 校验一个参数列表
      * @param params  参数列表
@@ -50,13 +72,20 @@ export class ValidateUtils {
      */
     public static validateParameters(params: Parameter[], options?: ParamValidateOptions): NodeValidationDetails {
         const allCodes = params.map(param => param.code);
+        const allNames = params.map(param => (param.name || '').trim() || param.code);
         const getAllCodes = () => allCodes;
-        options = { ...options, getAllCodes };
         let messages: string[] = [];
-
         (params ?? []).forEach((param) => {
-            const codeError = ParamValidateUtils.validateCode(param.code, options);
+            const codeError = ParamValidateUtils.validateCode(param.code, { ...options, getAllCodes });
             codeError && messages.push(codeError);
+            messages.push(...this.validateJsonSchema(param.schema, options));
+            const name = (param.name || '').trim();
+            if (name) {
+                const sames = allNames.filter((item) => item === name);
+                if (sames.length > 1) {
+                    messages.push(`显示名称不可重复`);
+                }
+            }
         });
         (params ?? []).forEach((param) => {
             const valueError = ParamValidateUtils.validateValue(param.valueExpr, options);
diff --git a/ai-flow-front/packages/flow-devkit/lib/utils/value-express.ts b/ai-flow-front/packages/flow-devkit/lib/utils/value-express.ts
index 981535855ce853e9d4bfeb44bac20e77d2599aeb..c404cd38398e61f4173e1dca0ad5d6a6de9d9a0a 100644
--- a/ai-flow-front/packages/flow-devkit/lib/utils/value-express.ts
+++ b/ai-flow-front/packages/flow-devkit/lib/utils/value-express.ts
@@ -2,20 +2,25 @@ import type {
     Parameter, FlowNodeInstance, NodeVariableExpr, SystemVariableExpr, BoolConstExpr, NumberConstExpr,
     StringConstExpr, StringsConstExpr, SelectorBranch, LogicExpr, CompareExpr,
     ValueExpress, CompareOperatorType, AssignValueExpr, MethodInvokeExpr,
-    MethodParameter,
+    MethodParameter, ValueExpressType, NodeData, TypeMethod, TypeRefer
 } from '@farris/flow-devkit/types';
-import { LogicOperator, ValueExpressKind } from '@farris/flow-devkit/types';
+import { NODE_VARIABLES_KEY } from '@farris/flow-devkit/constants';
+import { type NodeVariables, useTypeDetails } from '@farris/flow-devkit/composition';
+import { useMethodTypes } from '@farris/flow-devkit/hooks';
+import { LogicOperator, ValueExpressKind, BasicTypeRefer, JsonSchemaBasicType } from '@farris/flow-devkit/types';
 import { uuid } from './uuid';
+import { JsonSchemaUtils } from './json-schema';
 
 export class ValueExpressUtils {
 
-    public static createNodeVariableExpr(param: Parameter, node: FlowNodeInstance, fields?: string[]): NodeVariableExpr {
+    public static createNodeVariableExpr(param: Parameter, node: FlowNodeInstance, fields?: string[], fieldIds?: string[]): NodeVariableExpr {
         return {
             kind: ValueExpressKind.nodeVariable,
             nodeCode: node.data.code,
             variable: param.code,
-            fields: fields || [],
             variableId: param.id,
+            fields: fields || [],
+            fieldIds,
         };
     }
 
@@ -102,14 +107,170 @@ export class ValueExpressUtils {
     }
 
     public static isNodeVariableExpr(value: ValueExpress): value is NodeVariableExpr {
-        return value.kind === ValueExpressKind.nodeVariable;
+        return !!value && value.kind === ValueExpressKind.nodeVariable;
     }
 
     public static isSystemVariableExpr(value: ValueExpress): value is SystemVariableExpr {
-        return value.kind === ValueExpressKind.systemVariable;
+        return !!value && value.kind === ValueExpressKind.systemVariable;
     }
 
     public static isCompareExpr(value: ValueExpress): value is CompareExpr {
-        return value.kind === ValueExpressKind.compare;
+        return !!value && value.kind === ValueExpressKind.compare;
+    }
+
+    public static isMethodInvokeExpr(value: any): value is MethodInvokeExpr {
+        return (
+            !!value &&
+            typeof value === "object" &&
+            value.kind === ValueExpressKind.methodInvoke &&
+            !!value.typeUrl &&
+            !!value.methodCode
+        );
+    }
+
+    public static getMethodTypeByMethodInvokeExpr(express: MethodInvokeExpr): TypeMethod | undefined {
+        if (!this.isMethodInvokeExpr(express)) {
+            return undefined;
+        }
+        const typeRefer: TypeRefer = {
+            source: 'default',
+            typeId: express.typeUrl!,
+        };
+        const { mergedMethodTypes } = useMethodTypes();
+        const methodType = mergedMethodTypes.value.find((type) => {
+            return type.source === typeRefer.source && type.typeId === typeRefer.typeId;
+        });
+        const methods = methodType?.methods || [];
+        return methods.find((method) => {
+            return method.code === express.methodCode;
+        });
+    }
+
+    public static getReturnTypeByMethodInvokeExpr(express: MethodInvokeExpr): TypeRefer | undefined {
+        const method = this.getMethodTypeByMethodInvokeExpr(express);
+        return method?.returnType;
+    }
+
+    public static getTargetParameter(express: NodeVariableExpr, params: Parameter[]): Parameter | undefined {
+        const targetById = params.find((item) => {
+            return item.id === express.variableId && item.id && item.code;
+        });
+        if (targetById) {
+            if (express.variable !== targetById.code) {
+                express.variable = targetById.code;
+            }
+            return targetById;
+        }
+        const targetByCode = params.find((item) => {
+            return item.code === express.variable && item.code;
+        });
+        if (targetByCode) {
+            express.variableId = targetByCode.id;  // 重新跟踪变化
+        }
+        return targetByCode;
+    }
+
+    /**
+     * 获取常量表达式的类型信息
+     * @description 对于其它类型的表达式一律返回`undefined`
+     * @param constValueExpress 常量表达式
+     * @returns 值表达式的类型信息
+     */
+    public static getConstValueExpressType(express: ValueExpress): ValueExpressType | undefined {
+        if (!express || !express.kind) {
+            return undefined;
+        }
+        switch (express.kind) {
+            case ValueExpressKind.boolConst:
+                return { type: BasicTypeRefer.BooleanType };
+            case ValueExpressKind.numberConst:
+                return { type: BasicTypeRefer.NumberType };
+            case ValueExpressKind.stringConst:
+                return { type: BasicTypeRefer.StringType };
+            case ValueExpressKind.stringsConst:
+                return { type: BasicTypeRefer.StringArrayType };
+        }
+        return undefined;
+    }
+
+    /**
+     * 获取节点变量引用表达式的类型信息
+     * @description 对于其它类型的表达式一律返回`undefined`
+     * @param express  节点变量引用表达式
+     * @param nodeData 值表达式所属节点的数据
+     * @returns 值表达式的类型信息
+     */
+    public static getNodeVariableExpressType(express: ValueExpress, nodeData: NodeData): ValueExpressType | undefined {
+        if (!express || !nodeData || !this.isNodeVariableExpr(express)) {
+            return undefined;
+        }
+        const nodeVarsList: NodeVariables[] = nodeData[NODE_VARIABLES_KEY];
+        if (!Array.isArray(nodeVarsList)) {
+            return undefined;
+        }
+        const nodeCode = express.nodeCode;
+        const nodeVariables = nodeVarsList.find(
+            (item) => item.node.data.code === nodeCode
+        );
+        const targetParam = this.getTargetParameter(express, nodeVariables?.params || []);
+        if (!targetParam) {
+            return undefined;
+        }
+        if (JsonSchemaUtils.mayHasJsonSchema(targetParam.type)) {
+            const fieldIds = express.fieldIds;
+            if (!fieldIds || !fieldIds.length) {
+                return { type: targetParam.type, schema: targetParam.schema };
+            }
+            const fieldSchema = JsonSchemaUtils.getFieldJsonSchema(targetParam.schema, fieldIds);
+            if (!fieldSchema) {
+                return undefined;
+            }
+            return { type: JsonSchemaUtils.getTypeRefer(fieldSchema)!, schema: fieldSchema };
+        } else {
+            const { getFieldTypeRefer } = useTypeDetails();
+            const type = getFieldTypeRefer(targetParam.type, express.fields);
+            if (type) {
+                return { type };
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * 获取值表达式的类型信息
+     * @description 目前仅支持推断`节点变量引用表达式`和`常量表达式`的类型，其它一律返回`undefined`，待后续完善
+     * @param express  值表达式
+     * @param nodeData 值表达式所属节点的数据
+     * @returns 值表达式的类型信息
+     */
+    public static getValueExpressType(express: ValueExpress, nodeData: NodeData): ValueExpressType | undefined {
+        const constValueExpressType = this.getConstValueExpressType(express);
+        if (constValueExpressType) {
+            return constValueExpressType;
+        }
+        const nodeVariableExpressType = this.getNodeVariableExpressType(express, nodeData);
+        if (nodeVariableExpressType) {
+            return nodeVariableExpressType;
+        }
+        return undefined;
+    }
+
+    public static unwrapValueExpressType(valueExpressType?: ValueExpressType): ValueExpressType | undefined {
+        if (!valueExpressType) {
+            return undefined;
+        }
+        const { type, schema } = valueExpressType;
+        if (schema && schema.type === JsonSchemaBasicType.Array) {
+            const itemSchema = schema.items;
+            const itemType = JsonSchemaUtils.getTypeRefer(itemSchema);
+            if (itemType) {
+                return { type: itemType, schema: itemSchema };
+            }
+        }
+        const itemType = type.genericTypes?.[0];
+        if (itemType) {
+            return { type: itemType };
+        }
+        return undefined;
     }
 }
diff --git a/ai-flow-front/packages/flow-devkit/package.json b/ai-flow-front/packages/flow-devkit/package.json
index fa2bc8e53c1eb8f6886955ef6dd8b451d89df471..3a7dbcd7abf24397353cc4e756b30fbdbea3feb1 100644
--- a/ai-flow-front/packages/flow-devkit/package.json
+++ b/ai-flow-front/packages/flow-devkit/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@farris/flow-devkit",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "Apache-2.0",
   "private": true,
   "type": "module",