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

package/dist/services/classicNodePorts.js

@@ -1,18 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLASSIC_NODE_DESCRIPTORS = exports.LEGACY_HANDLE_NAME_MAP = exports.SWITCH_NODE_PACKAGE_KEY = exports.SWITCH_DEFAULT_BRANCH_HANDLE = void 0;
+exports.CLASSIC_PORT_TYPES = exports.LEGACY_HANDLE_NAME_MAP = void 0;
 exports.normalizeLegacyHandleName = normalizeLegacyHandleName;
-exports.isClassicNodeType = isClassicNodeType;
+exports.resolveSwitchBranchOutputs = resolveSwitchBranchOutputs;
 exports.resolveClassicNodePorts = resolveClassicNodePorts;
-exports.readSwitchBranches = readSwitchBranches;
-exports.deriveSwitchOutputPorts = deriveSwitchOutputPorts;
-exports.resolveClassicNodeSchema = resolveClassicNodeSchema;
-exports.getAutoConnectRulesForNodeType = getAutoConnectRulesForNodeType;
-exports.applySwitchBranchesToSchema = applySwitchBranchesToSchema;
-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';
+exports.isClassicSelfConnectionAllowed = isClassicSelfConnectionAllowed;
+const nodeEnvelope_1 = require("@/utils/nodeEnvelope");
+const switchBranch_1 = require("@/utils/switchBranch");
+/**
+ * 经典节点静态端口表（对齐 rcs nodeTypeRegistry.tsx CLASSIC_DESCRIPTORS）。
+ *
+ * 覆盖 legacy 节点（无 action_key/action_ver）的端口校验回退：
+ * - ConditionNode：出桩 true/false（max=1）
+ * - LoopNode / SelfLoopNode：出桩 done/loop（max=1），loop→input 自环允许
+ * - AgentNode / BrowserNode：底部 ai_model/ai_memory/ai_tool slave 入桩
+ * - MCP 系：MCPServer/MCP_TRIGGER_NODE（builtin_mcp 出桩）、BuiltinMCP、
+ *   MCP_TOOL/MCP_TOOLS_NODE（builtin_mcp 入桩 + main 出桩）
+ * - SwitchNode：动态分支端口 = branches[].id + default-branch
+ */
 /**
  * 废弃 handle 名迁移表（对齐 RCS useDataLoading REPLACE_HANDLE_MAP）：
  * 旧数据的 sourceHandle/targetHandle 可能仍是 chat_model/memory/tools，
@@ -29,385 +34,179 @@ function normalizeLegacyHandleName(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 = [];
-const ACTION_INPUTS = [
-    { name: 'input', displayName: '输入', maxConnections: 1 },
-];
-const ACTION_OUTPUTS = [
-    { name: 'output', displayName: '输出', maxConnections: 1 },
-];
-const TRIGGER_OUTPUTS = [
-    { name: 'output', displayName: '输出', maxConnections: 1 },
-];
-const CONDITION_OUTPUTS = [
-    { name: 'true', displayName: 'true', maxConnections: 1 },
-    { name: 'false', displayName: 'false', maxConnections: 1 },
-];
-const LOOP_OUTPUTS = [
-    { name: 'done', displayName: 'done', maxConnections: 1 },
-    { name: 'loop', displayName: 'loop', maxConnections: 1 },
-];
-const SWITCH_DEFAULT_OUTPUTS = [
-    { name: exports.SWITCH_DEFAULT_BRANCH_HANDLE, displayName: 'default', maxConnections: 1 },
-];
-/**
- * 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 },
+/** rcs NodeProtocol（enums/node.ts）取值 */
+exports.CLASSIC_PORT_TYPES = {
+    MAIN: 'main',
+    AI_LANGUAGE_MODEL: 'AI_LANGUAGE_MODEL',
+    AI_VECTOR_STORE: 'AI_VECTORSTORE',
+    AI_MEMORY: 'AI_MEMORY',
+    AI_TOOL: 'AI_TOOL',
+    BUILTIN_MCP: 'BUILTIN_MCP',
+    MCP_SERVER: 'MCP_SERVER',
+};
+const port = (p) => ({
+    name: p.name,
+    type: p.type ?? exports.CLASSIC_PORT_TYPES.MAIN,
+    maxConnections: p.max === undefined ? null : p.max,
+});
+const ports = (list) => list.map(port);
+const MAIN_IN = { name: 'input', max: 1 };
+const MAIN_OUT = { name: 'output', max: 1 };
+const LOOP_SELF_CONNECTIONS = [{ source: 'loop', target: 'input' }];
+/** Agent/Browser 底部 slave 入桩（协议对齐 rcs AGENT_INPUTS/BROWSER_INPUTS）。
+ *  ai_tool 为多协议桩（RCS 6fc6de5 后）：AI_TOOL 与 BUILTIN_MCP 链路均合法 */
+const AI_SLAVE_INPUTS = [
+    MAIN_IN,
+    { name: 'ai_model', type: exports.CLASSIC_PORT_TYPES.AI_LANGUAGE_MODEL, max: 1 },
+    { name: 'ai_memory', type: exports.CLASSIC_PORT_TYPES.AI_MEMORY, max: 1 },
     {
         name: 'ai_tool',
-        displayName: 'Tools',
-        type: 'AI_TOOL,KNOWLEDGE,MCP_SERVER,BUILTIN_MCP',
-        maxConnections: 10,
+        type: `${exports.CLASSIC_PORT_TYPES.AI_TOOL},${exports.CLASSIC_PORT_TYPES.BUILTIN_MCP}`,
+        max: 1,
     },
 ];
-/** 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 },
+/** MCPServer / MCP_TRIGGER_NODE：顶部 MCP_SERVER 入桩，底部 BUILTIN_MCP 出桩（不限连接数） */
+const MCP_SERVER_INPUTS = [{ name: 'input', type: exports.CLASSIC_PORT_TYPES.MCP_SERVER }];
+const MCP_SERVER_OUTPUTS = [
+    { name: 'builtin_mcp', type: exports.CLASSIC_PORT_TYPES.BUILTIN_MCP },
 ];
-/** AI 子节点顶部入桩（RCS 82b5976 方向翻转后为 TARGET）：端口名固定 input，协议随类型 */
-const aiSubInput = (protocol, maxConnections = 1) => ({
-    name: 'input',
-    displayName: '输入',
-    type: protocol,
-    maxConnections,
-});
-/**
- * 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：builtin_mcp 入桩 max 1，output 主出桩 max 10（协议 main） */
+/** BuiltinMCP：顶部 main 入桩，底部 BUILTIN_MCP 出桩（max=1） */
+const BUILTIN_MCP_INPUTS = [MAIN_IN];
 const BUILTIN_MCP_OUTPUTS = [
-    { name: 'output', displayName: '输出', maxConnections: 10 },
-];
-/** MCPTool / MCP_TOOLS_NODE：BUILTIN_MCP 入桩，main 出桩 */
-const MCP_TOOL_INPUTS = [
-    { name: 'input', displayName: '输入', type: 'BUILTIN_MCP' },
+    { name: 'builtin_mcp', type: exports.CLASSIC_PORT_TYPES.BUILTIN_MCP, max: 1 },
 ];
-const MCP_TOOL_OUTPUTS = [
-    { name: 'output', displayName: '输出', maxConnections: 1 },
-];
-/** MCP return-variable 等形态：无出桩 */
-const NO_OUTPUT_PROTOCOLS = {
-    BUILTIN_MCP: { outputs: EMPTY_PORTS },
-    MCP_SERVER: { outputs: EMPTY_PORTS },
-};
-/**
- * classic 静态端口表（唯一事实源，数据对齐 RCS CLASSIC_DESCRIPTORS）。
- */
-exports.CLASSIC_NODE_DESCRIPTORS = {
-    StartEventNode: {
-        nodeType: 'StartEventNode',
-        label: '触发器节点',
-        description: '流程触发起点，无输入端口，单输出口',
-        inputs: EMPTY_PORTS,
-        outputs: TRIGGER_OUTPUTS,
-    },
-    ActionNode: {
-        nodeType: 'ActionNode',
-        label: '动作节点',
-        description: '常规动作节点；MCP return-variable 协议形态无输出端口',
-        inputs: ACTION_INPUTS,
-        outputs: ACTION_OUTPUTS,
-        byProtocol: NO_OUTPUT_PROTOCOLS,
-    },
-    ConditionNode: {
-        nodeType: 'ConditionNode',
-        label: '条件节点',
-        description: '条件分支，true/false 双出口',
-        inputs: ACTION_INPUTS,
-        outputs: CONDITION_OUTPUTS,
-    },
-    LoopNode: {
-        nodeType: 'LoopNode',
-        label: '循环节点',
-        description: '循环控制，done 出口走完流程，loop 出口配合 input 形成自环',
-        inputs: ACTION_INPUTS,
-        outputs: LOOP_OUTPUTS,
-        autoConnect: LOOP_AUTO_CONNECT,
-    },
-    SelfLoopNode: {
-        nodeType: 'SelfLoopNode',
-        label: '自环节点',
-        description: '自循环控制，loop → input 自环边为必需结构',
-        inputs: ACTION_INPUTS,
-        outputs: LOOP_OUTPUTS,
-        autoConnect: LOOP_AUTO_CONNECT,
-    },
-    SwitchNode: {
-        nodeType: 'SwitchNode',
-        label: '多分支节点',
-        description: '多路由分支；输出端口来自 properties.branches[].id（实例派生），default-branch 固定兜底',
-        inputs: ACTION_INPUTS,
-        outputs: SWITCH_DEFAULT_OUTPUTS,
-    },
-    AgentNode: {
-        nodeType: 'AgentNode',
-        label: 'Agent 节点',
-        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: AGENT_OUTPUTS,
-    },
-    BrowserNode: {
-        nodeType: 'BrowserNode',
-        label: '浏览器节点',
-        description: 'AI 浏览器操作；ai_model slave 桩为连线源，指向 AISubNode 顶部 input 桩（协议 AI_LANGUAGE_MODEL）',
-        inputs: BROWSER_INPUTS,
-        outputs: BROWSER_OUTPUTS,
-    },
-    AISubNode: {
-        nodeType: 'AISubNode',
-        label: 'AI 配置子节点',
-        description: 'AI 配置子节点（模型/记忆/工具）；顶部 input 桩接收 Agent slave 桩连线，协议随类型（AI_TOOL 形态 max 10）',
-        inputs: [aiSubInput('AI_LANGUAGE_MODEL', 1)],
-        outputs: EMPTY_PORTS,
-        byProtocol: {
-            AI_MEMORY: { inputs: [aiSubInput('AI_MEMORY')] },
-            AI_TOOL: { inputs: [aiSubInput('AI_TOOL', 10)] },
-        },
-    },
-    VectorStoreNode: {
-        nodeType: 'VectorStoreNode',
-        label: '向量存储节点',
-        description: '向量存储子节点；protocol=AI_VECTORSTORE 时顶部 input 桩接收 Agent slave 桩连线',
-        inputs: EMPTY_PORTS,
-        outputs: EMPTY_PORTS,
-        byProtocol: {
-            // 注意拼写：对齐 RCS NodeProtocol.AI_VECTOR_STORE = 'AI_VECTORSTORE'
-            AI_VECTORSTORE: { inputs: [aiSubInput('AI_VECTORSTORE')] },
-        },
-    },
-    MCPServerNode: {
-        nodeType: 'MCPServerNode',
-        label: 'MCP 服务节点',
-        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 网关触发形态；builtin_mcp 入桩（BUILTIN_MCP 协议）max 1，无出桩',
-        inputs: MCP_BUILTIN_MCP_INPUTS,
-        outputs: EMPTY_PORTS,
-    },
-    BuiltinMCPNode: {
-        nodeType: 'BuiltinMCPNode',
-        label: '内置 MCP 节点',
-        description: '内置 MCP 工具节点；builtin_mcp 入桩（BUILTIN_MCP 协议）max 1，output 主出桩 max 10',
-        inputs: MCP_BUILTIN_MCP_INPUTS,
-        outputs: BUILTIN_MCP_OUTPUTS,
-    },
-    MCPToolNode: {
-        nodeType: 'MCPToolNode',
-        label: 'MCP 工具节点',
-        description: 'MCP 工具调用；BUILTIN_MCP 入桩，MCP return-variable 形态无出桩',
-        inputs: MCP_TOOL_INPUTS,
-        outputs: MCP_TOOL_OUTPUTS,
-        byProtocol: NO_OUTPUT_PROTOCOLS,
-    },
-    MCP_TOOLS_NODE: {
-        nodeType: 'MCP_TOOLS_NODE',
-        label: 'MCP 网关工具列表节点',
-        description: 'MCP 网关工具列表形态，端口与 MCPToolNode 一致',
-        inputs: MCP_TOOL_INPUTS,
-        outputs: MCP_TOOL_OUTPUTS,
-        byProtocol: NO_OUTPUT_PROTOCOLS,
-    },
-    StickyNoteNode: {
-        nodeType: 'StickyNoteNode',
-        label: '便签节点',
-        description: '画布便签，无端口',
-        inputs: EMPTY_PORTS,
-        outputs: EMPTY_PORTS,
-    },
-};
-function toNodeSchemaPort(spec) {
-    return {
-        name: spec.name,
-        display_name: spec.displayName,
-        type: spec.type ?? 'main',
-        ...(spec.maxConnections !== undefined && spec.maxConnections !== null
-            ? { max_connections: spec.maxConnections }
-            : {}),
-    };
-}
-/** node_type 是否命中内置表 */
-function isClassicNodeType(nodeType) {
-    return (Boolean(nodeType) &&
-        Object.prototype.hasOwnProperty.call(exports.CLASSIC_NODE_DESCRIPTORS, nodeType));
-}
-/**
- * 按 (node_type, protocol) 解析端口声明。
- * protocol 缺失或未命中 byProtocol 时回退 type 级默认；未知 node_type 返回 null。
- */
-function resolveClassicNodePorts(node) {
-    const descriptor = node.node_type ? exports.CLASSIC_NODE_DESCRIPTORS[node.node_type] : undefined;
-    if (!descriptor)
-        return null;
-    const protocol = node.protocol?.trim();
-    if (protocol) {
-        const override = descriptor.byProtocol?.[protocol];
-        if (override) {
-            return {
-                inputs: override.inputs ?? descriptor.inputs,
-                outputs: override.outputs ?? descriptor.outputs,
-            };
-        }
-    }
-    return { inputs: descriptor.inputs, outputs: descriptor.outputs };
+/** MCP_TOOL / MCP_TOOLS_NODE：顶部 BUILTIN_MCP 入桩，底部 main 出桩 */
+const MCP_TOOL_INPUTS = [{ name: 'input', type: exports.CLASSIC_PORT_TYPES.BUILTIN_MCP }];
+const MCP_TOOL_OUTPUTS = [MAIN_OUT];
+const NO_PORTS = { inputs: [], outputs: [], selfConnections: [] };
+/** protocol 覆盖：MCP return-variable 等形态无出桩（rcs byProtocol 语义） */
+const EMPTY_OUTPUTS_PROTOCOLS = new Set([
+    exports.CLASSIC_PORT_TYPES.BUILTIN_MCP,
+    exports.CLASSIC_PORT_TYPES.MCP_SERVER,
+]);
+function basePorts(inputs, outputs, selfConnections = []) {
+    return { inputs: ports(inputs), outputs: ports(outputs), selfConnections };
 }
-/** 探测 + 规范化节点 branches（RCS switchNodePackage 语义：三容器探测 + id 修复） */
-function readSwitchBranches(data) {
-    const raw = unwrapSwitchProperties(data);
-    const branches = Array.isArray(raw?.branches) ? raw.branches : [];
-    const normalized = [];
-    const usedIds = new Set([exports.SWITCH_DEFAULT_BRANCH_HANDLE]);
-    let migrated = 0;
-    for (const item of branches) {
-        if (!item || typeof item !== 'object')
-            continue;
-        const branch = item;
-        let id = String(branch.id ?? '');
-        const name = String(branch.name ?? '').trim() || `分支 ${normalized.length + 1}`;
-        if (!id.startsWith('branch') || id === exports.SWITCH_DEFAULT_BRANCH_HANDLE || usedIds.has(id)) {
-            do {
-                migrated++;
-                id = `branch-migrated-${migrated}`;
-            } while (usedIds.has(id));
-        }
-        usedIds.add(id);
-        normalized.push({ id, name });
+/** 节点 data.protocol → 端口覆盖（rcs resolveNodePorts byProtocol 分支） */
+function applyProtocolOverride(base, protocol) {
+    if (!protocol || !EMPTY_OUTPUTS_PROTOCOLS.has(protocol)) {
+        return base;
     }
-    return normalized;
+    return { ...base, outputs: [] };
 }
-/** 按序探测 config_schema → properties → params，各解包一层 properties/params */
-function unwrapSwitchProperties(data) {
-    const candidates = [data.config_schema, data.properties, data.params];
-    for (const candidate of candidates) {
-        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
-            continue;
-        const unwrapped = unwrapPropertiesLayer(candidate);
-        if (Array.isArray(unwrapped?.branches))
-            return unwrapped;
-    }
-    return undefined;
+function readProtocol(node) {
+    const raw = (node.properties ?? {});
+    const protocol = raw.protocol;
+    return typeof protocol === 'string' && protocol ? protocol : undefined;
 }
-function unwrapPropertiesLayer(value) {
-    if (Array.isArray(value.branches))
-        return value;
-    const nested = value.properties;
-    if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
-        const unwrapped = nested;
-        if (Array.isArray(unwrapped.branches))
-            return unwrapped;
-    }
-    const params = value.params;
-    if (params && typeof params === 'object' && !Array.isArray(params)) {
-        const unwrapped = params;
-        if (Array.isArray(unwrapped.branches))
-            return unwrapped;
+/** 从 properties（含 NodePackage 信封形态）提取 branches[].id（rcs switchNodePackage 语义） */
+function readSwitchBranchIds(node) {
+    const props = (node.properties ?? {});
+    if (!props || typeof props !== 'object')
+        return [];
+    let container = props;
+    if (!Array.isArray(container.branches)) {
+        const unwrapped = (0, nodeEnvelope_1.unwrapNodePackagePropertiesEnvelope)(props);
+        if (unwrapped !== props &&
+            unwrapped &&
+            typeof unwrapped === 'object' &&
+            Array.isArray(unwrapped.branches)) {
+            container = unwrapped;
+        }
     }
-    return value;
+    if (!Array.isArray(container.branches))
+        return [];
+    return container.branches
+        .map((branch) => {
+        if (!branch || typeof branch !== 'object' || Array.isArray(branch))
+            return null;
+        const id = branch.id;
+        return typeof id === 'string' && id ? id : null;
+    })
+        .filter((id) => id !== null);
 }
 /**
- * branches → 输出端口。classic SwitchNode 用静态模板（main/max1）；
- * NodePackage switch 通过 options 传 schema 模板以继承约束。
- * default-branch 固定追加在末尾；branches 为空时仅返回 [defaultPort]。
+ * SwitchNode 动态分支端口派生：端口 = branches[].id + default-branch
+ * （对齐 rcs resolveSwitchNodePackagePortSchema，分支端口 max=1）
  */
-function deriveSwitchOutputPorts(branches, options) {
-    const template = options?.template ?? {
-        name: 'branch-1',
-        display_name: '分支',
-        type: 'main',
-        max_connections: 1,
-    };
-    const defaultPort = options?.defaultPort ?? {
-        name: exports.SWITCH_DEFAULT_BRANCH_HANDLE,
-        display_name: 'default',
-        type: 'main',
-        max_connections: 1,
-    };
+function resolveSwitchBranchOutputs(branchIds) {
     return [
-        ...branches.map((branch) => ({
-            ...template,
-            name: branch.id,
-            display_name: branch.name,
-        })),
-        defaultPort,
+        ...branchIds.map((id) => port({ name: id, max: 1 })),
+        port({ name: switchBranch_1.DEFAULT_BRANCH_HANDLE, max: 1 }),
     ];
 }
 /**
- * 完整解析 classic 节点的内置 schema（含 SwitchNode 实例分支派生）。
- * 未知 node_type 返回 null。
+ * 按 (node_type, protocol, branches) 解析经典节点端口表。
+ *
+ * node_type 为 rcs NodeType 枚举值（如 'ConditionNode'、'LoopNode'）。
+ * 未知类型返回 null（调用方回退行为不回退）。
  */
-function resolveClassicNodeSchema(node) {
-    const descriptor = node.node_type ? exports.CLASSIC_NODE_DESCRIPTORS[node.node_type] : undefined;
-    if (!descriptor)
-        return null;
-    const ports = resolveClassicNodePorts(node) ?? {
-        inputs: descriptor.inputs,
-        outputs: descriptor.outputs,
-    };
-    // Switch 分支端口由 deriveSwitchOutputPorts 产出（已是 NodeSchemaPort），不能再过 toNodeSchemaPort
-    const outputs = node.node_type === 'SwitchNode'
-        ? deriveSwitchOutputPorts(readSwitchBranches(node))
-        : (ports.outputs ?? []).map(toNodeSchemaPort);
-    return {
-        schemaKey: node.node_type,
-        inputs: (ports.inputs ?? []).map(toNodeSchemaPort),
-        outputs,
-        autoConnect: descriptor.autoConnect ?? [],
-    };
-}
-/** Loop/SelfLoop 的 loop→input 兜底（NodePackage 节点也按 node_type 注入，对齐 RCS nodeAutoConnect） */
-function getAutoConnectRulesForNodeType(nodeType) {
-    if (!nodeType)
-        return [];
-    const descriptor = exports.CLASSIC_NODE_DESCRIPTORS[nodeType];
-    return descriptor?.autoConnect ?? [];
+function resolveClassicNodePorts(node) {
+    const nodeType = node.node_type || 'ActionNode';
+    const protocol = readProtocol(node);
+    let base;
+    switch (nodeType) {
+        case 'ActionNode':
+        case 'dynamic':
+        case 'custom':
+            base = basePorts([MAIN_IN], [MAIN_OUT]);
+            break;
+        case 'StartEventNode':
+            base = basePorts([], [MAIN_OUT]);
+            break;
+        case 'ConditionNode':
+            base = basePorts([MAIN_IN], [
+                { name: 'true', max: 1 },
+                { name: 'false', max: 1 },
+            ]);
+            break;
+        case 'LoopNode':
+        case 'SelfLoopNode':
+            base = basePorts([MAIN_IN], [
+                { name: 'done', max: 1 },
+                { name: 'loop', max: 1 },
+            ], LOOP_SELF_CONNECTIONS);
+            break;
+        case 'SwitchNode': {
+            const branchIds = readSwitchBranchIds(node);
+            base = basePorts([MAIN_IN], resolveSwitchBranchOutputs(branchIds));
+            break;
+        }
+        case 'AgentNode':
+        case 'BrowserNode':
+            base = basePorts(AI_SLAVE_INPUTS, [MAIN_OUT]);
+            break;
+        case 'AISubNode':
+        case 'VectorStoreNode':
+            // AI 子节点只有出桩；协议由 data.protocol 决定（默认 AI_LANGUAGE_MODEL）
+            base = basePorts([], [{ name: 'ai_model', type: protocol ?? exports.CLASSIC_PORT_TYPES.AI_LANGUAGE_MODEL, max: 1 }]);
+            break;
+        case 'StickyNoteNode':
+            return NO_PORTS;
+        case 'MCPServerNode':
+        case 'MCP_TRIGGER_NODE':
+            base = basePorts(MCP_SERVER_INPUTS, MCP_SERVER_OUTPUTS);
+            break;
+        case 'BuiltinMCPNode':
+            base = basePorts(BUILTIN_MCP_INPUTS, BUILTIN_MCP_OUTPUTS);
+            break;
+        case 'MCPToolNode':
+        case 'MCP_TOOLS_NODE':
+            base = basePorts(MCP_TOOL_INPUTS, MCP_TOOL_OUTPUTS);
+            break;
+        default:
+            return null;
+    }
+    return applyProtocolOverride(base, protocol);
 }
 /**
- * NodePackage switch schema 应用实例分支（schema.key === 'dip.core.flow.switch' 时，
- * 模板继承 schema 第一个非 default 输出的约束）；其余 schema 原样返回。
+ * 判断自环边是否被节点 auto_connect 规则声明
+ * （对齐 rcs connectionCheck.ts / nodeAutoConnect.ts isSelfConnectionAllowed 语义）。
  */
-function applySwitchBranchesToSchema(schema, node) {
-    if (schema.key !== exports.SWITCH_NODE_PACKAGE_KEY)
-        return schema;
-    const branches = readSwitchBranches(node);
-    if (branches.length === 0)
-        return schema;
-    const schemaOutputs = schema.outputs ?? [];
-    const template = schemaOutputs.find((port) => port.name !== exports.SWITCH_DEFAULT_BRANCH_HANDLE) ??
-        { name: 'branch-1', display_name: '分支', type: 'main' };
-    const defaultPort = schemaOutputs.find((port) => port.name === exports.SWITCH_DEFAULT_BRANCH_HANDLE) ??
-        {
-            name: exports.SWITCH_DEFAULT_BRANCH_HANDLE,
-            display_name: 'Default',
-            type: 'main',
-        };
-    return {
-        ...schema,
-        outputs: deriveSwitchOutputPorts(branches, { template, defaultPort }),
-    };
-}
-/** skills 渲染用：全部内置类型（保持表定义顺序） */
-function listClassicNodeTypes() {
-    return Object.values(exports.CLASSIC_NODE_DESCRIPTORS).map((d) => ({
-        nodeType: d.nodeType,
-        label: d.label,
-    }));
+function isClassicSelfConnectionAllowed(node, sourceHandle, targetHandle) {
+    if (!sourceHandle || !targetHandle)
+        return false;
+    const portsTable = resolveClassicNodePorts(node);
+    return Boolean(portsTable?.selfConnections.some((rule) => rule.source === sourceHandle && rule.target === targetHandle));
 }
 //# sourceMappingURL=classicNodePorts.js.map