digitalsee-ai-flow-cli 0.9.23-beta → 0.9.24-beta

package/dist/api/node.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActionDetail = getActionDetail;
 exports.getActionNodeSchema = getActionNodeSchema;
 exports.isNodePackageSupported = isNodePackageSupported;
 exports.getNodeDetail = getNodeDetail;
@@ -12,6 +13,17 @@ exports.cancelDebugNode = cancelDebugNode;
 const client_1 = require("@/api/client");
 const knowledge_1 = require("@/api/knowledge");
 const encoding_1 = require("@/utils/encoding");
+/**
+ * Legacy action detail lookup by numeric backend action id.
+ *
+ * Use `getActionNodeSchema(nodeKey, version)` instead for NodePackage nodes,
+ * whose persistent identity is `action_key + action_ver` — the path params
+ * there are the string action key and the numeric action version, not a
+ * backend id.
+ */
+async function getActionDetail(id, version) {
+    return await (0, client_1.apiGet)(`/acm/actions/${id}${version ? '/' + version : ''}`);
+}
 function parseMaybeJson(value) {
     if (typeof value !== 'string') {
         return value;

package/dist/commands/flow/edge.js

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const flow_1 = require("@/api/flow");
 const helpers_1 = require("@/commands/flow/helpers");
 const portValidator_1 = require("@/services/portValidator");
+const classicNodePorts_1 = require("@/services/classicNodePorts");
 const output_1 = require("@/utils/output");
 function registerFlowEdge(flowCmd) {
     const edgeCmd = flowCmd.command('edge').description('边（连接）操作');
@@ -72,12 +73,14 @@ function registerFlowEdge(flowCmd) {
             const flow = await (0, flow_1.getFlowDetail)(options.flowId);
             if ((0, helpers_1.checkFlowNotOnline)(flow, !!options.json))
                 return;
+            // 存量边读取时做废弃 handle 名迁移（对齐 RCS useDataLoading REPLACE_HANDLE_MAP，
+            // 迁移后的新名随本次保存写回后端）
             const existingEdges = (flow.edges || []).map((e) => ({
                 id: e.id,
                 source: e.source,
                 target: e.target,
-                sourceHandle: e.sourceHandle || 'output',
-                targetHandle: e.targetHandle || 'input',
+                sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(e.sourceHandle) || 'output',
+                targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(e.targetHandle) || 'input',
                 type: e.type || 'main',
             }));
             let newEdges = [];
@@ -117,30 +120,48 @@ function registerFlowEdge(flowCmd) {
                     }
                     return;
                 }
-                newEdges = edgesData.map((e, i) => {
+                newEdges = await Promise.all(edgesData.map(async (e, i) => {
                     const edge = e;
                     if (!edge.source || !edge.target) {
                         throw new Error(`第 ${i + 1} 条边缺少 source 或 target`);
                     }
+                    const sourceHandle = String(edge.sourceHandle || 'output');
+                    const targetHandle = String(edge.targetHandle || 'input');
                     return {
                         id: `${String(edge.source)}-${String(edge.target)}-${Date.now() + i}`,
                         source: String(edge.source),
                         target: String(edge.target),
-                        sourceHandle: String(edge.sourceHandle || 'output'),
-                        targetHandle: String(edge.targetHandle || 'input'),
-                        type: String(edge.type || 'main'),
+                        sourceHandle,
+                        targetHandle,
+                        // 显式 type 优先（兼容手工构造的批量 JSON），否则按 NP schema 解析
+                        type: edge.type !== undefined && edge.type !== null && String(edge.type).trim() !== ''
+                            ? String(edge.type)
+                            : await (0, portValidator_1.resolveEdgeSaveType)(flow.nodes, {
+                                source: String(edge.source),
+                                target: String(edge.target),
+                                sourceHandle,
+                                targetHandle,
+                            }),
                     };
-                });
+                }));
             }
             else {
+                // 连线保存 type 对齐 RCS EdgeFactory：NodePackage handle 项的 type，否则 main
+                const sourceHandle = options.sourceHandle || 'output';
+                const targetHandle = options.targetHandle || 'input';
                 newEdges = [
                     {
                         id: `${options.source}-${options.target}-${Date.now()}`,
                         source: options.source,
                         target: options.target,
-                        sourceHandle: options.sourceHandle || 'output',
-                        targetHandle: options.targetHandle || 'input',
-                        type: 'main',
+                        sourceHandle,
+                        targetHandle,
+                        type: await (0, portValidator_1.resolveEdgeSaveType)(flow.nodes, {
+                            source: options.source,
+                            target: options.target,
+                            sourceHandle,
+                            targetHandle,
+                        }),
                     },
                 ];
             }
@@ -225,14 +246,15 @@ function registerFlowEdge(flowCmd) {
             const flow = await (0, flow_1.getFlowDetail)(options.flowId);
             if ((0, helpers_1.checkFlowNotOnline)(flow, !!options.json))
                 return;
+            // 同 connect：存量边做废弃 handle 名迁移后写回
             const remainingEdges = (flow.edges || [])
                 .filter((e) => !edgeIds.includes(e.id))
                 .map((e) => ({
                 id: e.id,
                 source: e.source,
                 target: e.target,
-                sourceHandle: e.sourceHandle || 'output',
-                targetHandle: e.targetHandle || 'input',
+                sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(e.sourceHandle) || 'output',
+                targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(e.targetHandle) || 'input',
                 type: e.type || 'main',
             }));
             const connections = (0, helpers_1.edgesToConnections)(remainingEdges);

package/dist/commands/flow/node.js

@@ -67,12 +67,12 @@ function parseActionIdRef(actionId) {
     return { key: actionId };
 }
 /**
- * 按解析结果获取动作（以 RCS 为标准，旧 API 已移除）：
+ * 按解析结果获取动作（以 RCS 为标准）：
  * a. `key@version` → getActionNodeSchema（NodePackage 权威 schema）
- * b. `key`（需 linkId）→ connectable 按 link_id 解析（RCS loadConnectableNodeActions 语义），
+ * b. 纯数字 → getActionDetail（legacy /acm/actions/:id，Long id 直接作创建身份）
+ * c. `key`（需 linkId）→ connectable 按 link_id 解析（RCS loadConnectableNodeActions 语义），
  *    创建身份遵循 RCS resolveClassicCreateActionId：Long id 直接用，否则 '0' 哨兵
  *    （真实身份是 action_key + action_ver）
- * c. 纯数字 legacy 动作 id 不再支持（/acm/actions/:id 已移除）
  */
 async function resolveAction(actionId, ctx) {
     const ref = parseActionIdRef(actionId);
@@ -80,7 +80,15 @@ async function resolveAction(actionId, ctx) {
         const nodeSchema = await (0, node_1.getActionNodeSchema)(ref.key, ref.version);
         return nodeSchemaToAction(nodeSchema);
     }
-    if (!ref.key || !ctx.linkId) {
+    if (!ref.key) {
+        try {
+            return await (0, node_1.getActionDetail)(actionId);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!ctx.linkId) {
         return undefined;
     }
     const result = await (0, knowledge_1.searchNodesByCategory)({
@@ -109,13 +117,6 @@ function toClassicCreateActionId(action) {
     }
     return '0';
 }
-/** 纯数字 id 已随旧 API 移除，给出引导文案 */
-function actionNotFoundMessage(actionId) {
-    if (/^\d+$/.test(actionId.trim())) {
-        return `未找到动作 ${actionId}：本版本不再支持纯数字动作 id，请使用 action_key 或 action_key@version（可用 knowledge actions 查看）`;
-    }
-    return `未找到动作 ${actionId}`;
-}
 function nodeSchemaToAction(nodeSchema) {
     return {
         // legacy 哨兵：仅创建接口需要 action_id，不能作为动作持久身份
@@ -319,7 +320,7 @@ function registerFlowNode(flowCmd) {
                 action.id = '0';
             }
             if (!action) {
-                const msg = actionNotFoundMessage(actionId);
+                const msg = `未找到动作 ${actionId}`;
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
@@ -637,7 +638,7 @@ function registerFlowNode(flowCmd) {
                     trigger: nd.node_type === 'StartEventNode',
                 });
                 if (!replacedAction) {
-                    const msg = actionNotFoundMessage(options.actionId);
+                    const msg = `未找到动作 ${options.actionId}`;
                     if (options.json)
                         (0, output_1.printStructuredResult)({ ok: false, message: msg });
                     else

package/dist/services/classicNodePorts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLASSIC_NODE_DESCRIPTORS = exports.SWITCH_NODE_PACKAGE_KEY = exports.SWITCH_DEFAULT_BRANCH_HANDLE = void 0;
+exports.CLASSIC_NODE_DESCRIPTORS = exports.LEGACY_HANDLE_NAME_MAP = exports.SWITCH_NODE_PACKAGE_KEY = exports.SWITCH_DEFAULT_BRANCH_HANDLE = void 0;
+exports.normalizeLegacyHandleName = normalizeLegacyHandleName;
 exports.isClassicNodeType = isClassicNodeType;
 exports.resolveClassicNodePorts = resolveClassicNodePorts;
 exports.readSwitchBranches = readSwitchBranches;
@@ -12,6 +13,22 @@ exports.listClassicNodeTypes = listClassicNodeTypes;
 exports.SWITCH_DEFAULT_BRANCH_HANDLE = 'default-branch';
 /** NodePackage switch 的 action_key（dip.core.flow.switch） */
 exports.SWITCH_NODE_PACKAGE_KEY = 'dip.core.flow.switch';
+/**
+ * 废弃 handle 名迁移表（对齐 RCS useDataLoading REPLACE_HANDLE_MAP）：
+ * 旧数据的 sourceHandle/targetHandle 可能仍是 chat_model/memory/tools，
+ * 读取时统一替换为 ai_model/ai_memory/ai_tool
+ */
+exports.LEGACY_HANDLE_NAME_MAP = {
+    chat_model: 'ai_model',
+    memory: 'ai_memory',
+    tools: 'ai_tool',
+};
+/** handle 名规范化：空值返回 undefined，命中废弃名时替换，其余原样返回 */
+function normalizeLegacyHandleName(handle) {
+    if (!handle)
+        return undefined;
+    return exports.LEGACY_HANDLE_NAME_MAP[handle] ?? handle;
+}
 /** Loop / SelfLoop 的 loop → input 自环规则（NodePackage 节点也按 node_type 兜底注入） */
 const LOOP_AUTO_CONNECT = [{ source: 'loop', target: 'input' }];
 const EMPTY_PORTS = [];
@@ -35,34 +52,45 @@ const LOOP_OUTPUTS = [
 const SWITCH_DEFAULT_OUTPUTS = [
     { name: exports.SWITCH_DEFAULT_BRANCH_HANDLE, displayName: 'default', maxConnections: 1 },
 ];
-const AGENT_INPUTS = [
-    { name: 'input', displayName: '输入' },
+/**
+ * Agent 底部 slave 桩为 SOURCE（RCS 82b5976 方向翻转）：连线从 Agent 出发，
+ * 指向 AI 子节点顶部 input 桩。ai_tool 允许多协议（临时兼容，对齐 RCS）
+ */
+const AGENT_INPUTS = [{ name: 'input', displayName: '输入' }];
+const AGENT_OUTPUTS = [
+    { name: 'output', displayName: '输出', maxConnections: 1 },
     { name: 'ai_model', displayName: 'Chat Model', type: 'AI_LANGUAGE_MODEL', maxConnections: 1 },
     { name: 'ai_memory', displayName: 'Memory', type: 'AI_MEMORY', maxConnections: 1 },
-    { name: 'ai_tool', displayName: 'Tools', type: 'AI_TOOL', maxConnections: 1 },
+    {
+        name: 'ai_tool',
+        displayName: 'Tools',
+        type: 'AI_TOOL,KNOWLEDGE,MCP_SERVER,BUILTIN_MCP',
+        maxConnections: 10,
+    },
 ];
-const BROWSER_INPUTS = [
-    { name: 'input', displayName: '输入' },
+/** BrowserNode（RCS 0f824ad 方向翻转）：ai_model slave 桩为连线源，指向 AISubNode 顶部 input 桩 */
+const BROWSER_INPUTS = [{ name: 'input', displayName: '输入' }];
+const BROWSER_OUTPUTS = [
+    { name: 'output', displayName: '输出' },
     { name: 'ai_model', displayName: 'Chat Model', type: 'AI_LANGUAGE_MODEL', maxConnections: 1 },
 ];
-/** AI 子节点出桩：id 固定 ai_model（与存量边数据兼容），type 随协议替换 */
-const aiSubOutput = (protocol) => ({
-    name: 'ai_model',
-    displayName: '输出',
+/** AI 子节点顶部入桩（RCS 82b5976 方向翻转后为 TARGET）：端口名固定 input，协议随类型 */
+const aiSubInput = (protocol, maxConnections = 1) => ({
+    name: 'input',
+    displayName: '输入',
     type: protocol,
-    maxConnections: 1,
+    maxConnections,
 });
-/** MCPServer / MCP_TRIGGER_NODE：入桩 MCP_SERVER 协议，出桩 BUILTIN_MCP 不限连接数 */
-const MCP_SERVER_INPUTS = [
-    { name: 'input', displayName: '输入', type: 'MCP_SERVER' },
-];
-const MCP_SERVER_OUTPUTS = [
-    { name: 'builtin_mcp', displayName: '输出', type: 'BUILTIN_MCP' },
+/**
+ * MCP 网关系列（RCS 6fc6de5 后）：builtin_mcp 顶部入桩（TARGET，BUILTIN_MCP 协议，max 1），
+ * 连线源为 Agent ai_tool（多协议含 BUILTIN_MCP）等
+ */
+const MCP_BUILTIN_MCP_INPUTS = [
+    { name: 'builtin_mcp', displayName: '输入', type: 'BUILTIN_MCP', maxConnections: 1 },
 ];
-/** BuiltinMCP：main 入桩，BUILTIN_MCP 出桩 max 1 */
-const BUILTIN_MCP_INPUTS = [{ name: 'input', displayName: '输入' }];
+/** BuiltinMCP：builtin_mcp 入桩 max 1，output 主出桩 max 10（协议 main） */
 const BUILTIN_MCP_OUTPUTS = [
-    { name: 'builtin_mcp', displayName: '输出', type: 'BUILTIN_MCP', maxConnections: 1 },
+    { name: 'output', displayName: '输出', maxConnections: 10 },
 ];
 /** MCPTool / MCP_TOOLS_NODE：BUILTIN_MCP 入桩，main 出桩 */
 const MCP_TOOL_INPUTS = [
@@ -128,58 +156,58 @@ exports.CLASSIC_NODE_DESCRIPTORS = {
     AgentNode: {
         nodeType: 'AgentNode',
         label: 'Agent 节点',
-        description: 'AI Agent；底部 slave 桩按协议接收 AI 子节点（ai_model/ai_memory/ai_tool）',
+        description: 'AI Agent；底部 slave 桩（ai_model/ai_memory/ai_tool）为连线源，指向 AI 子节点顶部 input 桩；ai_tool 支持多协议（AI_TOOL,KNOWLEDGE,MCP_SERVER,BUILTIN_MCP）',
         inputs: AGENT_INPUTS,
-        outputs: ACTION_OUTPUTS,
+        outputs: AGENT_OUTPUTS,
     },
     BrowserNode: {
         nodeType: 'BrowserNode',
         label: '浏览器节点',
-        description: 'AI 浏览器操作；ai_model slave 桩接收语言模型子节点',
+        description: 'AI 浏览器操作；ai_model slave 桩为连线源，指向 AISubNode 顶部 input 桩（协议 AI_LANGUAGE_MODEL）',
         inputs: BROWSER_INPUTS,
-        outputs: ACTION_OUTPUTS,
+        outputs: BROWSER_OUTPUTS,
     },
     AISubNode: {
         nodeType: 'AISubNode',
         label: 'AI 配置子节点',
-        description: 'AI 配置子节点（模型/记忆/工具），出桩 id 固定 ai_model，协议随类型',
-        inputs: EMPTY_PORTS,
-        outputs: [aiSubOutput('AI_LANGUAGE_MODEL')],
+        description: 'AI 配置子节点（模型/记忆/工具）；顶部 input 桩接收 Agent slave 桩连线，协议随类型（AI_TOOL 形态 max 10）',
+        inputs: [aiSubInput('AI_LANGUAGE_MODEL', 1)],
+        outputs: EMPTY_PORTS,
         byProtocol: {
-            AI_MEMORY: { outputs: [aiSubOutput('AI_MEMORY')] },
-            AI_TOOL: { outputs: [aiSubOutput('AI_TOOL')] },
+            AI_MEMORY: { inputs: [aiSubInput('AI_MEMORY')] },
+            AI_TOOL: { inputs: [aiSubInput('AI_TOOL', 10)] },
         },
     },
     VectorStoreNode: {
         nodeType: 'VectorStoreNode',
         label: '向量存储节点',
-        description: '向量存储子节点',
+        description: '向量存储子节点；protocol=AI_VECTORSTORE 时顶部 input 桩接收 Agent slave 桩连线',
         inputs: EMPTY_PORTS,
-        outputs: [aiSubOutput('AI_LANGUAGE_MODEL')],
+        outputs: EMPTY_PORTS,
         byProtocol: {
             // 注意拼写：对齐 RCS NodeProtocol.AI_VECTOR_STORE = 'AI_VECTORSTORE'
-            AI_VECTORSTORE: { outputs: [aiSubOutput('AI_VECTORSTORE')] },
+            AI_VECTORSTORE: { inputs: [aiSubInput('AI_VECTORSTORE')] },
         },
     },
     MCPServerNode: {
         nodeType: 'MCPServerNode',
         label: 'MCP 服务节点',
-        description: '旧 MCP 网关服务；入桩 MCP_SERVER 协议，builtin_mcp 出桩不限连接数',
-        inputs: MCP_SERVER_INPUTS,
-        outputs: MCP_SERVER_OUTPUTS,
+        description: '旧 MCP 网关服务；builtin_mcp 入桩（BUILTIN_MCP 协议）max 1，无出桩',
+        inputs: MCP_BUILTIN_MCP_INPUTS,
+        outputs: EMPTY_PORTS,
     },
     MCP_TRIGGER_NODE: {
         nodeType: 'MCP_TRIGGER_NODE',
         label: 'MCP 网关触发节点',
-        description: '旧 MCP 网关触发形态，端口与 MCPServerNode 一致',
-        inputs: MCP_SERVER_INPUTS,
-        outputs: MCP_SERVER_OUTPUTS,
+        description: '旧 MCP 网关触发形态；builtin_mcp 入桩（BUILTIN_MCP 协议）max 1，无出桩',
+        inputs: MCP_BUILTIN_MCP_INPUTS,
+        outputs: EMPTY_PORTS,
     },
     BuiltinMCPNode: {
         nodeType: 'BuiltinMCPNode',
         label: '内置 MCP 节点',
-        description: '内置 MCP 工具节点，BUILTIN_MCP 出桩 max 1',
-        inputs: BUILTIN_MCP_INPUTS,
+        description: '内置 MCP 工具节点；builtin_mcp 入桩（BUILTIN_MCP 协议）max 1，output 主出桩 max 10',
+        inputs: MCP_BUILTIN_MCP_INPUTS,
         outputs: BUILTIN_MCP_OUTPUTS,
     },
     MCPToolNode: {

package/dist/services/portValidator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_PORT_TYPE = void 0;
 exports.validateFlowPorts = validateFlowPorts;
 exports.validateSingleEdge = validateSingleEdge;
+exports.resolveEdgeSaveType = resolveEdgeSaveType;
 const nodeSchemaCache_1 = require("@/utils/nodeSchemaCache");
 const classicNodePorts_1 = require("@/services/classicNodePorts");
 exports.DEFAULT_PORT_TYPE = 'main';
@@ -32,10 +33,17 @@ const formatHandleList = (ports) => ports.length
     : '（无）';
 const includesKey = (keys, identity) => Boolean(identity && keys.includes(identity));
 const rejectedByAllowlist = (keys, identity) => Boolean(keys.length && !includesKey(keys, identity));
+/** 协议/type 列表交集匹配（大小写不敏感；对齐 RCS connectionCheck 多协议兼容逻辑） */
+function protocolListsOverlap(sourceType, targetType) {
+    const sourceList = sourceType.split(',').map((p) => p.trim().toLowerCase());
+    const targetList = targetType.split(',').map((p) => p.trim().toLowerCase());
+    return sourceList.some((sp) => targetList.includes(sp));
+}
 /** 端口间协议/白黑名单规则校验（不含 max_connections 与 required，二者按端口聚合检查） */
 function checkPortRules(sourcePort, targetPort, sourceIdentity, targetIdentity) {
-    // 协议/type 比较大小写不敏感（对齐 RCS connectionCheck；对存量只放宽不收紧）
-    if (sourcePort.type.toLowerCase() !== targetPort.type.toLowerCase()) {
+    // 协议/type 比较大小写不敏感，支持逗号分隔多协议列表交集（对齐 RCS connectionCheck）
+    if (sourcePort.type.toLowerCase() !== targetPort.type.toLowerCase() &&
+        !protocolListsOverlap(sourcePort.type, targetPort.type)) {
         return 'PORT_TYPE_MISMATCH';
     }
     // 黑名单优先于白名单：同一个 node key 同时出现时必须拒绝
@@ -212,6 +220,14 @@ function validateRequiredInputs(entries, edges) {
     }
     return violations;
 }
+/** 边 handle 规范化：废弃 handle 名（chat_model/memory/tools 等）替换为新名（对齐 RCS 加载迁移） */
+function normalizeEdgeHandles(edges) {
+    return edges.map((edge) => ({
+        ...edge,
+        sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(edge.sourceHandle),
+        targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(edge.targetHandle),
+    }));
+}
 /**
  * 对 flow 全量 nodes + edges 做 node_schema 端口级校验。
  *
@@ -220,16 +236,17 @@ function validateRequiredInputs(entries, edges) {
  */
 async function validateFlowPorts(input) {
     const { entries, unresolved } = await resolveNodeSchemas(input.nodes);
+    const edges = normalizeEdgeHandles(input.edges);
     const violations = [];
-    for (const edge of input.edges) {
+    for (const edge of edges) {
         const sourceEntry = entries.get(edge.source);
         const targetEntry = entries.get(edge.target);
         // 只有两端都有 node_schema 时才做端口级校验（legacy 端跳过，避免误报）
         if (sourceEntry && targetEntry) {
-            violations.push(...validateEdge(edge, sourceEntry, targetEntry, input.edges));
+            violations.push(...validateEdge(edge, sourceEntry, targetEntry, edges));
         }
     }
-    violations.push(...validateRequiredInputs(entries, input.edges));
+    violations.push(...validateRequiredInputs(entries, edges));
     return {
         violations,
         checkedNodeCount: entries.size,
@@ -252,9 +269,36 @@ async function validateSingleEdge(input) {
         id: '(new-edge)',
         source: input.newEdge.source,
         target: input.newEdge.target,
-        sourceHandle: input.newEdge.sourceHandle,
-        targetHandle: input.newEdge.targetHandle,
+        sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(input.newEdge.sourceHandle),
+        targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(input.newEdge.targetHandle),
     };
-    return validateEdge(edge, sourceEntry, targetEntry, [...input.existingEdges, edge]);
+    return validateEdge(edge, sourceEntry, targetEntry, [
+        ...normalizeEdgeHandles(input.existingEdges),
+        edge,
+    ]);
+}
+/**
+ * 解析连线的保存 type（对齐 RCS EdgeFactory ef7558b 语义）：
+ * 仅 NodePackage 节点的 handle 参与——源侧为 NP 时取其 schema 输出项的 type，
+ * 否则目标侧为 NP 时取其 schema 输入项的 type，都不是则 'main'。
+ * classic 节点的协议不写入连线 type。
+ */
+async function resolveEdgeSaveType(nodes, edge) {
+    const findNode = (id) => nodes.find((n) => (n.n_id || n.id) === id);
+    const sourceNode = findNode(edge.source);
+    if (sourceNode?.action_key && sourceNode.action_ver !== undefined) {
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(sourceNode.action_key), Number(sourceNode.action_ver));
+        const port = schema?.outputs?.find((p) => p.name === ((0, classicNodePorts_1.normalizeLegacyHandleName)(edge.sourceHandle) || exports.DEFAULT_PORT_TYPE));
+        if (port?.type)
+            return port.type;
+    }
+    const targetNode = findNode(edge.target);
+    if (targetNode?.action_key && targetNode.action_ver !== undefined) {
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(targetNode.action_key), Number(targetNode.action_ver));
+        const port = schema?.inputs?.find((p) => p.name === ((0, classicNodePorts_1.normalizeLegacyHandleName)(edge.targetHandle) || exports.DEFAULT_PORT_TYPE));
+        if (port?.type)
+            return port.type;
+    }
+    return exports.DEFAULT_PORT_TYPE;
 }
 //# sourceMappingURL=portValidator.js.map

package/dist/services/skillGenerator.js

@@ -251,10 +251,15 @@ function renderClassicExampleCommands(descriptor) {
     for (const rule of descriptor.autoConnect ?? []) {
         lines.push(`# 自环边（必需结构）：`, `ai-flow flow edge connect --flow-id <flowId> --source <${descriptor.nodeType}的节点ID> --target <同节点ID> --source-handle ${rule.source} --target-handle ${rule.target}`);
     }
-    // AI slave 桩：源侧用 AISubNode 的 ai_model 出桩
+    // AI slave 桩（连线方向对齐 RCS 82b5976：slave 桩为源，指向 AI 子节点顶部 input 桩）
+    const slaveOutput = descriptor.outputs.find((p) => p.name.startsWith('ai_'));
+    if (slaveOutput) {
+        lines.push(`# AI 子节点接入（${descriptor.nodeType} 的 ${slaveOutput.name} 桩为连线源，AISubNode 顶部 input 桩为目标）：`, `ai-flow flow edge connect --flow-id <flowId> --source <${descriptor.nodeType}的节点ID> --source-handle ${slaveOutput.name} --target <AISubNode节点ID> --target-handle input`);
+    }
+    // 仍作为目标的 slave 入桩（如 BrowserNode ai_model）：协议匹配的源是 AgentNode 的 ai_model 出桩
     const slaveInput = descriptor.inputs.find((p) => p.name.startsWith('ai_'));
     if (slaveInput) {
-        lines.push(`# AI 子节点接入 ${slaveInput.name} 桩（源侧为 AISubNode 出桩）：`, `ai-flow flow edge connect --flow-id <flowId> --source <AISubNode节点ID> --target <${descriptor.nodeType}的节点ID> --source-handle ai_model --target-handle ${slaveInput.name}`);
+        lines.push(`# AI 子节点接入 ${slaveInput.name} 桩（源侧用 AgentNode 的同协议 ai_model 出桩）：`, `ai-flow flow edge connect --flow-id <flowId> --source <AgentNode节点ID> --source-handle ai_model --target <${descriptor.nodeType}的节点ID> --target-handle ${slaveInput.name}`);
     }
     lines.push('```', '');
     return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "digitalsee-ai-flow-cli",
-  "version": "0.9.23-beta",
+  "version": "0.9.24-beta",
   "description": "AI Flow CLI - manage connection flows and node configurations",
   "main": "dist/index.js",
   "bin": {