@digitalsee-ai/rcs 1.0.16 → 1.1.1

package/dist/components/digitalsee/workflow/events/eventBus.d.ts

@@ -1,16 +1,6 @@
 import { NodeTypeItem } from '../Panels/ModernNodeSelectorPanel/types';
-export interface NodeAddInfo {
-    sourceNodeId?: string;
-    sourceHandle?: string;
-    targetNodeId?: string;
-    targetHandle?: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    trigger?: boolean;
-    edge?: any;
-}
+import { NodeAddInfo } from '../types/NodeAddContext';
+export type { NodeAddInfo } from '../types/NodeAddContext';
 export type NodeAddEvent = {
     info: NodeAddInfo;
     nodeType: NodeTypeItem;

package/dist/components/digitalsee/workflow/hooks/use-nodes-interaction.d.ts

@@ -1,5 +1,5 @@
-import { NodeMouseHandler, OnNodesChange } from '@xyflow/react';
 import { NodeType } from '../types/Node';
+import { NodeMouseHandler, OnNodesChange } from '@xyflow/react';
 export declare const useNodesInteraction: () => {
     autoSaveNum: number;
     onNodeMouseEnter: NodeMouseHandler;

package/dist/components/digitalsee/workflow/hooks/usePanel.d.ts

@@ -1,23 +1,9 @@
 import { ActionItem } from '../Panels/ModernNodeSelectorPanel/types';
-export interface NodeAddInfo {
-    sourceNodeId?: string;
-    sourceHandle?: string;
-    targetNodeId?: string;
-    targetHandle?: string;
-    position?: {
-        x: number;
-        y: number;
-    };
-    edge?: any;
-    sourceNode?: any;
-    targetNode?: any;
-    trigger?: boolean;
-    protocol?: string;
-    refresh?: boolean;
-}
+import { NodeAddInfo } from '../types/NodeAddContext';
+export type { NodeAddInfo } from '../types/NodeAddContext';
 export declare function usePanel(): {
     nodeSelectorVisible: boolean;
-    nodeAddInfo: import('../store/panelSlice').NodeAddInfo;
+    nodeAddInfo: NodeAddInfo;
     openNodeSelector: (info: NodeAddInfo) => void;
     closeNodeSelector: () => void;
     handleNodeSelect: (nodeType: ActionItem) => void;

package/dist/components/digitalsee/workflow/index.d.ts

@@ -90,7 +90,8 @@ export interface DigitalseeWorkFlowProps {
     /**
      * 引擎模式
      *
-     * @description 'classic' 使用 ACM 后端，'next' 使用 DIP 后端 + DynamicForm
+     * @description 'classic' 是当前 AI 连接流主路径，使用 ACM 后端，并兼容渲染
+     * nodepackage 节点的新版 NodeSchema 配置；'next' 是暂废保留的 DIP 直连分支。
      * @default 'classic'
      */
     engineMode?: EngineMode;

package/dist/components/digitalsee/workflow/store/panelSlice.d.ts

@@ -1,17 +1,6 @@
 import { PayloadAction } from '@reduxjs/toolkit';
 import { ActionItem, NodeTypeItem } from '../Panels/ModernNodeSelectorPanel/types';
-export interface NodeAddInfo {
-    sourceNodeId: string;
-    sourceHandle: string;
-    targetNodeId?: string;
-    targetHandle?: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    trigger?: boolean;
-    protocol?: string;
-}
+import { NodeAddInfo } from '../types/NodeAddContext';
 type NodeAddCallback = ((info: NodeAddInfo, nodeType: ActionItem) => void) | null;
 export interface PanelState {
     nodeSelectorVisible: boolean;
@@ -22,68 +11,176 @@ export declare const panelSlice: import('@reduxjs/toolkit').Slice<PanelState, {
     openNodeSelector: (state: {
         nodeSelectorVisible: boolean;
         nodeAddInfo: {
-            sourceNodeId: string;
-            sourceHandle: string;
+            sourceNodeId?: string;
+            sourceHandle?: string;
             targetNodeId?: string;
             targetHandle?: string;
-            position: {
+            position?: {
                 x: number;
                 y: number;
             };
+            edge?: {
+                id: string;
+                source: string;
+                target: string;
+                sourceHandle?: string | null;
+                sourceHandleId?: string | null;
+                targetHandle?: string | null;
+                targetHandleId?: string | null;
+                data?: {
+                    [x: string]: unknown;
+                };
+            };
+            sourceNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
+            targetNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
             trigger?: boolean;
             protocol?: string;
+            refresh?: boolean;
         };
         nodeAddCallback: NodeAddCallback;
     }, action: PayloadAction<NodeAddInfo>) => void;
     closeNodeSelector: (state: {
         nodeSelectorVisible: boolean;
         nodeAddInfo: {
-            sourceNodeId: string;
-            sourceHandle: string;
+            sourceNodeId?: string;
+            sourceHandle?: string;
             targetNodeId?: string;
             targetHandle?: string;
-            position: {
+            position?: {
                 x: number;
                 y: number;
             };
+            edge?: {
+                id: string;
+                source: string;
+                target: string;
+                sourceHandle?: string | null;
+                sourceHandleId?: string | null;
+                targetHandle?: string | null;
+                targetHandleId?: string | null;
+                data?: {
+                    [x: string]: unknown;
+                };
+            };
+            sourceNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
+            targetNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
             trigger?: boolean;
             protocol?: string;
+            refresh?: boolean;
         };
         nodeAddCallback: NodeAddCallback;
     }) => void;
     setNodeAddCallback: (state: {
         nodeSelectorVisible: boolean;
         nodeAddInfo: {
-            sourceNodeId: string;
-            sourceHandle: string;
+            sourceNodeId?: string;
+            sourceHandle?: string;
             targetNodeId?: string;
             targetHandle?: string;
-            position: {
+            position?: {
                 x: number;
                 y: number;
             };
+            edge?: {
+                id: string;
+                source: string;
+                target: string;
+                sourceHandle?: string | null;
+                sourceHandleId?: string | null;
+                targetHandle?: string | null;
+                targetHandleId?: string | null;
+                data?: {
+                    [x: string]: unknown;
+                };
+            };
+            sourceNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
+            targetNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
             trigger?: boolean;
             protocol?: string;
+            refresh?: boolean;
         };
         nodeAddCallback: NodeAddCallback;
     }, action: PayloadAction<NodeAddCallback>) => void;
     executeNodeAddCallback: (state: {
         nodeSelectorVisible: boolean;
         nodeAddInfo: {
-            sourceNodeId: string;
-            sourceHandle: string;
+            sourceNodeId?: string;
+            sourceHandle?: string;
             targetNodeId?: string;
             targetHandle?: string;
-            position: {
+            position?: {
                 x: number;
                 y: number;
             };
+            edge?: {
+                id: string;
+                source: string;
+                target: string;
+                sourceHandle?: string | null;
+                sourceHandleId?: string | null;
+                targetHandle?: string | null;
+                targetHandleId?: string | null;
+                data?: {
+                    [x: string]: unknown;
+                };
+            };
+            sourceNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
+            targetNode?: {
+                data: {
+                    [x: string]: unknown;
+                };
+                id: string;
+                type?: string;
+            };
             trigger?: boolean;
             protocol?: string;
+            refresh?: boolean;
         };
         nodeAddCallback: NodeAddCallback;
     }, action: PayloadAction<NodeTypeItem>) => void;
 }, "panel", "panel", import('@reduxjs/toolkit').SliceSelectors<PanelState>>;
-export declare const openNodeSelector: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<NodeAddInfo, "panel/openNodeSelector">, closeNodeSelector: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"panel/closeNodeSelector">, setNodeAddCallback: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<(info: NodeAddInfo, nodeType: ActionItem) => void, "panel/setNodeAddCallback">, executeNodeAddCallback: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<NodeTypeItem, "panel/executeNodeAddCallback">;
+export declare const openNodeSelector: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"panel/openNodeSelector">, closeNodeSelector: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"panel/closeNodeSelector">, setNodeAddCallback: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<(info: NodeAddInfo, nodeType: ActionItem) => void, "panel/setNodeAddCallback">, executeNodeAddCallback: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<NodeTypeItem, "panel/executeNodeAddCallback">;
 declare const _default: import('@reduxjs/toolkit').Reducer<PanelState>;
 export default _default;

package/dist/components/digitalsee/workflow/types/Node.d.ts

@@ -22,7 +22,7 @@ export type NodeData = ActionItem & {
     /** 动作 ID */
     action_id?: string;
     /** 连接器 ID */
-    connector_id?: string;
+    connector_id?: string | null;
     /** 后端节点 ID */
     n_id?: string;
     /** 账号 ID */

package/dist/components/digitalsee/workflow/types/NodeAddContext.d.ts

@@ -0,0 +1,31 @@
+import { Node } from '@xyflow/react';
+/** 节点选择器只需保留 MCP 判定需要的轻量锚点信息，避免 Redux 声明泄漏 ReactFlow 样式类型。 */
+export type NodeAddAnchorNode = Pick<Node, 'id' | 'type' | 'data'>;
+/** 边上插入节点时保留的原边上下文。 */
+export interface NodeAddEdgeContext {
+    id: string;
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    sourceHandleId?: string | null;
+    targetHandle?: string | null;
+    targetHandleId?: string | null;
+    data?: Record<string, unknown>;
+}
+/** 节点选择器与节点创建回调共享的唯一新增上下文。 */
+export interface NodeAddInfo {
+    sourceNodeId?: string;
+    sourceHandle?: string;
+    targetNodeId?: string;
+    targetHandle?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    edge?: NodeAddEdgeContext;
+    sourceNode?: NodeAddAnchorNode;
+    targetNode?: NodeAddAnchorNode;
+    trigger?: boolean;
+    protocol?: string;
+    refresh?: boolean;
+}

package/dist/components/digitalsee/workflow/types/engine.d.ts

@@ -18,6 +18,7 @@ export interface CanvasEngineConfig {
     flowId: string;
     engineMode?: EngineMode;
     canvas: CanvasCoreConfig;
+    nodeSelector: NodeSelectorConfig;
     nodeTypes: NodeTypesRegistryConfig;
     edgeRules: EdgeRulesConfig;
     toolbar: ToolbarConfig;
@@ -25,6 +26,20 @@ export interface CanvasEngineConfig {
     httpClient?: HttpClient;
     history?: HistoryNavigator;
 }
+/**
+ * NodePackage 可连线候选能力配置。
+ *
+ * 默认关闭，由 CLASSIC/ACM 宿主显式启用，便于在接口联调异常时快速回退旧候选链路。
+ */
+export interface NodeSelectorConnectableConfig {
+    enabled: boolean;
+    scene: string;
+    fallbackToLegacy: boolean;
+    debug: boolean;
+}
+export interface NodeSelectorConfig {
+    connectable: NodeSelectorConnectableConfig;
+}
 type NativeReactFLowProps = ComponentProps<typeof ReactFlow>;
 export interface RegisterComponents {
     form: {
@@ -106,6 +121,8 @@ export interface EdgeConfig {
     id?: string;
     source: string;
     target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
     data?: Record<string, any>;
 }
 export interface EdgeContext {

package/dist/components/digitalsee/workflow/utils/classicNodeActionIdentity.d.ts

@@ -0,0 +1,7 @@
+import { ActionItem } from '../Panels/ModernNodeSelectorPanel/types';
+/**
+ * 解析 CLASSIC create-node API 使用的原始 Long action_id。
+ *
+ * NodePackage 的 UI key 通常是 actionKey，而后端 action id 可能为 0/负数；两者不可混用。
+ */
+export declare function resolveClassicCreateActionId(action: Pick<ActionItem, 'id' | 'backendActionId' | 'action_id'>): string;

package/dist/components/digitalsee/workflow/utils/classicNodeActionIdentity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/classicNodePackageConnection.d.ts

@@ -0,0 +1,28 @@
+import { DipNodeSchema } from '../api/dip';
+import { PortConnectionEdge, PortConnectionValidationCode } from './portConnectionValidator';
+import { Node } from '@xyflow/react';
+export type ClassicNodePackageConnectionCode = PortConnectionValidationCode | 'NOT_APPLICABLE' | 'SCHEMA_NOT_READY';
+export interface ClassicNodePackageConnectionResult {
+    applicable: boolean;
+    valid: boolean;
+    code: ClassicNodePackageConnectionCode;
+    reason: string;
+    missingSchemaNodeIds?: string[];
+}
+export interface ValidateClassicNodePackageConnectionInput {
+    sourceNode?: Node | null;
+    targetNode?: Node | null;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+    edges?: readonly PortConnectionEdge[];
+}
+/** 同步解析节点内联或已预加载的 CLASSIC nodepackage Schema。 */
+export declare function resolveClassicNodePackageSchema(node?: Node | null): DipNodeSchema | null;
+export declare function isClassicNodePackageNode(node?: Node | null): boolean;
+/**
+ * 校验两个 CLASSIC nodepackage 节点之间的端口连接。
+ *
+ * 混合 legacy/nodepackage 连接保留前端当前精确 handle 名称，并按后端虚拟端口契约
+ * 将 legacy 端口能力类型统一映射为 main。
+ */
+export declare function validateClassicNodePackageConnection({ sourceNode, targetNode, sourceHandle, targetHandle, edges, }: ValidateClassicNodePackageConnectionInput): ClassicNodePackageConnectionResult;

package/dist/components/digitalsee/workflow/utils/classicNodePackageConnection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/classicNodePackageGraphValidation.d.ts

@@ -0,0 +1,29 @@
+import { PortConnectionValidationCode } from './portConnectionValidator';
+import { Edge, Node } from '@xyflow/react';
+export type ClassicNodePackageGraphIssueCode = PortConnectionValidationCode | 'REQUIRED_INPUT_MISSING' | 'SCHEMA_NOT_READY';
+export interface ClassicNodePackageGraphIssue {
+    code: ClassicNodePackageGraphIssueCode;
+    reason: string;
+    blocking: boolean;
+    nodeId?: string;
+    portName?: string;
+    edgeId?: string;
+    sourceNodeId?: string;
+    targetNodeId?: string;
+}
+export interface ClassicNodePackageGraphValidationResult {
+    valid: boolean;
+    issues: ClassicNodePackageGraphIssue[];
+    blockingIssues: ClassicNodePackageGraphIssue[];
+    missingSchemaNodeIds: string[];
+}
+interface ValidateClassicNodePackageGraphInput {
+    nodes: readonly Node[];
+    edges: readonly Edge[];
+}
+/**
+ * 保存前检查当前已知的 CLASSIC nodepackage 端口约束。
+ * Schema 尚未加载属于非阻塞 warning，最终交给 ACM 后端兜底；已知非法端口则阻止保存。
+ */
+export declare function validateClassicNodePackageGraph({ nodes, edges, }: ValidateClassicNodePackageGraphInput): ClassicNodePackageGraphValidationResult;
+export {};

package/dist/components/digitalsee/workflow/utils/classicNodePackageGraphValidation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/compatiblePortSelection.d.ts

@@ -0,0 +1,79 @@
+import { DipNodeSchema } from '../api/dip.types';
+import { PortConnectionEdge, PortConnectionNode, PortConnectionValidationCode } from './portConnectionValidator';
+type SourceNodeSchema = Pick<DipNodeSchema, 'outputs'>;
+type TargetNodeSchema = Pick<DipNodeSchema, 'inputs'>;
+type InsertedNodeSchema = Pick<DipNodeSchema, 'inputs' | 'outputs'>;
+export type CompatiblePortSelectionCode = 'COMPATIBLE_PORT_PAIR_FOUND' | 'SOURCE_PORTS_EMPTY' | 'TARGET_PORTS_EMPTY' | 'SOURCE_HANDLE_NOT_FOUND' | 'TARGET_HANDLE_NOT_FOUND' | 'NO_COMPATIBLE_PORT_PAIR';
+/** 自动选端口的结构化结果；compatibleCount 大于 1 时调用方可记录歧义日志。 */
+export interface CompatiblePortSelectionResult {
+    valid: boolean;
+    code: CompatiblePortSelectionCode;
+    reason: string;
+    sourceHandle: string | null;
+    targetHandle: string | null;
+    compatibleCount: number;
+    /** 未找到组合时记录首个候选的底层校验码，便于 UI 映射文案。 */
+    validationCode: PortConnectionValidationCode | null;
+}
+export interface SelectCompatiblePortPairInput {
+    sourceNode: PortConnectionNode;
+    targetNode: PortConnectionNode;
+    sourceSchema: SourceNodeSchema;
+    targetSchema: TargetNodeSchema;
+    edges?: readonly PortConnectionEdge[];
+    /** 已存在的源 handle；缺失时按 sourceSchema.outputs 顺序枚举。 */
+    sourceHandle?: string | null;
+    /** 已存在的目标 handle；缺失时按 targetSchema.inputs 顺序枚举。 */
+    targetHandle?: string | null;
+}
+export interface SelectSourceToNewCompatiblePortInput {
+    sourceNode: PortConnectionNode;
+    newNode: PortConnectionNode;
+    sourceSchema: SourceNodeSchema;
+    newNodeSchema: TargetNodeSchema;
+    sourceHandle: string | null | undefined;
+    edges?: readonly PortConnectionEdge[];
+}
+export interface SelectNewToTargetCompatiblePortInput {
+    newNode: PortConnectionNode;
+    targetNode: PortConnectionNode;
+    newNodeSchema: SourceNodeSchema;
+    targetSchema: TargetNodeSchema;
+    targetHandle: string | null | undefined;
+    edges?: readonly PortConnectionEdge[];
+}
+export type EdgeInsertPortSelectionCode = 'EDGE_INSERT_PORTS_FOUND' | 'SOURCE_TO_NEW_INCOMPATIBLE' | 'NEW_TO_TARGET_INCOMPATIBLE';
+export interface EdgeInsertPortSelectionResult {
+    valid: boolean;
+    code: EdgeInsertPortSelectionCode;
+    reason: string;
+    /** 两段可选组合数的乘积。 */
+    compatibleCount: number;
+    sourceToNew: CompatiblePortSelectionResult;
+    newToTarget: CompatiblePortSelectionResult | null;
+}
+export interface SelectCompatiblePortsForEdgeInsertInput {
+    sourceNode: PortConnectionNode;
+    newNode: PortConnectionNode;
+    targetNode: PortConnectionNode;
+    sourceSchema: SourceNodeSchema;
+    newNodeSchema: InsertedNodeSchema;
+    targetSchema: TargetNodeSchema;
+    sourceHandle: string | null | undefined;
+    targetHandle: string | null | undefined;
+    edges?: readonly PortConnectionEdge[];
+    /** 插边成功后会替换的旧边；校验连接数时必须先排除。 */
+    replacedEdgeId?: string;
+}
+/**
+ * 按 source outputs → target inputs 的 Schema 顺序枚举所有组合。
+ * 会继续扫描首个成功组合之后的候选，以便返回准确的 compatibleCount。
+ */
+export declare const selectCompatiblePortPair: ({ sourceNode, targetNode, sourceSchema, targetSchema, sourceHandle, targetHandle, edges, }: SelectCompatiblePortPairInput) => CompatiblePortSelectionResult;
+/** 从已有输出端口增加新节点：仅枚举新节点 inputs。 */
+export declare const selectSourceToNewCompatiblePort: ({ sourceNode, newNode, sourceSchema, newNodeSchema, sourceHandle, edges, }: SelectSourceToNewCompatiblePortInput) => CompatiblePortSelectionResult;
+/** 从已有输入端口增加前置节点：仅枚举新节点 outputs。 */
+export declare const selectNewToTargetCompatiblePort: ({ newNode, targetNode, newNodeSchema, targetSchema, targetHandle, edges, }: SelectNewToTargetCompatiblePortInput) => CompatiblePortSelectionResult;
+/** 插边时同时选择 source→new 与 new→target 两段端口。 */
+export declare const selectCompatiblePortsForEdgeInsert: ({ sourceNode, newNode, targetNode, sourceSchema, newNodeSchema, targetSchema, sourceHandle, targetHandle, edges, replacedEdgeId, }: SelectCompatiblePortsForEdgeInsertInput) => EdgeInsertPortSelectionResult;
+export {};

package/dist/components/digitalsee/workflow/utils/compatiblePortSelection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/mcpCanvas.d.ts

@@ -0,0 +1,33 @@
+import { HandleConnectionType } from '../types/Handle';
+import { NodeProtocol } from '../types/NodeProtocol';
+import { Edge, Node } from '@xyflow/react';
+export declare const MCP_TRIGGER_CATEGORY = "MCP_TRIGGER";
+export declare const MCP_CATEGORY_TYPE = "mcp_trigger";
+export declare const MCP_ACTION_LINK_ID = "mcp-gateway";
+export declare const MCP_CATALOG_PAGE_SIZE = 200;
+export declare const MCP_ACTION_PAGE_SIZE = 10;
+export declare const MCP_SERVER_PROTOCOL = NodeProtocol.MCP_SERVER;
+export declare const MCP_MAX_TOOLS_PER_SERVER = 20;
+export declare const MCP_TOOL_MAX_DOWNSTREAM = 1;
+export declare const MCP_CANVAS_TARGET_HANDLE = "top";
+export declare const MCP_RETURN_VARIABLE_ACTION_KEY = "dip.core.mcp.return-variable";
+export declare const isMcpServerNode: (node?: Pick<Node, "type"> | null) => boolean;
+export declare const isMcpToolNode: (node?: Pick<Node, "type"> | null) => boolean;
+export declare const isMcpReturnVariableNode: (node?: (Pick<Node, "data"> & {
+    data?: Record<string, unknown>;
+}) | null) => boolean;
+export declare const isMcpCanvas: (nodes: Array<Pick<Node, "type">>) => boolean;
+export declare const isMcpServerCanvas: (nodes: Array<Pick<Node, "type">>) => boolean;
+export declare const markMcpServerCanvasNode: <T extends Node>(node: T) => T;
+export declare const isMcpServerToolHandle: (handleId?: string | null) => handleId is HandleConnectionType.BUILTIN_MCP;
+export declare const isMcpToolChainHandle: (handleId?: string | null) => handleId is "main" | HandleConnectionType.OUTPUT;
+export declare const getDirectMcpToolCount: (serverId: string, nodes: Array<Pick<Node, "id" | "type">>, edges: Array<Pick<Edge, "source" | "target">>) => number;
+export declare const canAddMoreMcpTools: (serverId: string, nodes: Array<Pick<Node, "id" | "type">>, edges: Array<Pick<Edge, "source" | "target">>) => boolean;
+export declare const getMcpToolDownstreamCount: (toolId: string, edges: Array<Pick<Edge, "source" | "sourceHandle">>) => number;
+export declare const canAddMcpToolDownstream: (toolId: string, edges: Array<Pick<Edge, "source" | "sourceHandle">>) => boolean;
+export declare const isMcpServerToToolConnection: (sourceNode?: Pick<Node, "type"> | null, targetNode?: Pick<Node, "type"> | null, sourceHandle?: string | null) => boolean;
+export declare const isMcpToolToExecutionConnection: (sourceNode?: Pick<Node, "id" | "type"> | null, targetNode?: Pick<Node, "id" | "type"> | null, sourceHandle?: string | null) => boolean;
+export declare const getNodeTypeById: (nodes: Array<Pick<Node, "id" | "type">>, nodeId?: string | null) => string;
+export declare const resolveMcpCanvasTargetHandle: (nodes: Array<Pick<Node, "type">>, fallback?: string | null) => string;
+export declare const normalizeMcpCanvasEdge: <T extends Pick<Edge, "targetHandle">>(nodes: Array<Pick<Node, "type">>, edge: T) => T;
+export declare const normalizeMcpCanvasEdges: <T extends Pick<Edge, "targetHandle">>(nodes: Array<Pick<Node, "type">>, edges: T[]) => T[];

package/dist/components/digitalsee/workflow/utils/mcpCanvas.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/nextNodeSchemaCache.d.ts

@@ -2,5 +2,13 @@ import { DipNodeSchema } from '../api/dip';
 export declare function clearNextNodeSchemaCache(): void;
 export declare function setCachedNextNodeSchema(nodeKey: string, nodeVersion: number | undefined, schema: DipNodeSchema): void;
 export declare function setCachedClassicNextNodeSchema(nodeKey: string, nodeVersion: number | undefined, schema: DipNodeSchema): void;
+/**
+ * 同步读取已预加载的 CLASSIC nodepackage Schema，不触发网络请求。
+ *
+ * 手动拖线发生在 ReactFlow 的同步校验阶段，无法等待异步 Schema 请求；
+ * 因此画布加载/选择器转换阶段会先预热缓存，再由这里读取。缺失版本时与
+ * `getCachedClassicNextNodeSchema` 保持一致，按 ACM 版本 1 兜底。
+ */
+export declare function peekCachedClassicNextNodeSchema(nodeKey: string, nodeVersion?: number): DipNodeSchema | null;
 export declare function getCachedClassicNextNodeSchema(nodeKey: string, nodeVersion?: number): Promise<DipNodeSchema | null>;
 export declare function getCachedNextNodeSchema(nodeKey: string, nodeVersion?: number): Promise<DipNodeSchema | null>;

package/dist/components/digitalsee/workflow/utils/nodeDataFormatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/digitalsee/workflow/utils/portConnectionValidationMessages.d.ts

@@ -0,0 +1,48 @@
+import { PortConnectionValidationResult } from './portConnectionValidator';
+import { TranslateFn } from '../../../../locales';
+/** 供选择器、自动连线和已有边检查复用的 connectable 界面文案。 */
+export declare const CONNECTABLE_UI_MESSAGE_IDS: {
+    readonly categoryUnavailable: "link.flow.connectable.category_unavailable";
+    readonly connectorUnavailable: "link.flow.connectable.connector_unavailable";
+    readonly actionUnavailable: "link.flow.connectable.action_unavailable";
+    readonly loadFailed: "link.flow.connectable.load_failed";
+    readonly noCompatibleNodes: "link.flow.connectable.no_compatible_nodes";
+    readonly noCompatibleInput: "link.flow.connectable.no_compatible_input";
+    readonly noCompatibleOutput: "link.flow.connectable.no_compatible_output";
+    readonly noBidirectionalCompatiblePort: "link.flow.connectable.no_bidirectional_compatible_port";
+    readonly schemaUnavailable: "link.flow.connectable.schema_unavailable";
+    readonly existingEdgeInvalid: "link.flow.connectable.existing_edge_invalid";
+};
+/**
+ * 端口校验错误码与 RCS 内置文案的唯一映射。
+ *
+ * 使用 `satisfies` 保证校验器新增 code 时这里会产生类型错误，避免界面静默回退成中文
+ * `reason`。`reason` 仍保留给未知后端规则或版本不一致场景作运行时兜底。
+ */
+export declare const PORT_CONNECTION_VALIDATION_MESSAGE_IDS: {
+    readonly SOURCE_NODE_NOT_FOUND: "link.flow.connectable.validation.source_node_not_found";
+    readonly TARGET_NODE_NOT_FOUND: "link.flow.connectable.validation.target_node_not_found";
+    readonly SOURCE_PORT_NOT_FOUND: "link.flow.connectable.validation.source_port_not_found";
+    readonly TARGET_PORT_NOT_FOUND: "link.flow.connectable.validation.target_port_not_found";
+    readonly PORT_TYPE_MISMATCH: "link.flow.connectable.validation.port_type_mismatch";
+    readonly SOURCE_NODE_NOT_ALLOWED: "link.flow.connectable.validation.source_node_not_allowed";
+    readonly TARGET_NODE_NOT_ALLOWED: "link.flow.connectable.validation.target_node_not_allowed";
+    readonly SOURCE_NODE_DENIED: "link.flow.connectable.validation.source_node_denied";
+    readonly TARGET_NODE_DENIED: "link.flow.connectable.validation.target_node_denied";
+    readonly SOURCE_MAX_CONNECTIONS_REACHED: "link.flow.connectable.validation.source_max_connections_reached";
+    readonly TARGET_MAX_CONNECTIONS_REACHED: "link.flow.connectable.validation.target_max_connections_reached";
+    readonly SELF_CONNECTION_NOT_ALLOWED: "link.flow.connectable.validation.self_connection_not_allowed";
+};
+/**
+ * 将端口连接校验结果转为当前 locale 的用户文案。
+ *
+ * @example
+ * ```ts
+ * const intl = useIntl();
+ * const text = formatPortConnectionValidationMessage(
+ *   validationResult,
+ *   (id, values) => intl.formatMessage({ id }, values),
+ * );
+ * ```
+ */
+export declare const formatPortConnectionValidationMessage: (result: PortConnectionValidationResult, translate: TranslateFn) => string;

package/dist/components/digitalsee/workflow/utils/portConnectionValidationMessages.test.d.ts

@@ -0,0 +1 @@
+export {};