@agentscope-ai/flow 0.0.1

package/dist/store/index.js

@@ -0,0 +1,146 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { debounce } from 'lodash-es';
+import { createStore } from 'zustand/vanilla';
+export var createWorkflowStore = function createWorkflowStore() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return createStore(function (set) {
+    return _objectSpread({
+      showResults: false,
+      setShowResults: function setShowResults(val) {
+        return set(function () {
+          return {
+            showResults: val
+          };
+        });
+      },
+      readyOnly: false,
+      setReadyOnly: function setReadyOnly(val) {
+        return set(function () {
+          return {
+            readyOnly: val
+          };
+        });
+      },
+      taskStore: void 0,
+      setTaskStore: function setTaskStore(val) {
+        return set(function () {
+          return {
+            taskStore: val
+          };
+        });
+      },
+      debounceSaveDraft: debounce(function (syncWorkflowDraft) {
+        syncWorkflowDraft();
+      }, 5000),
+      hiddenMenu: false,
+      setHiddenMenu: function setHiddenMenu(val) {
+        return set(function () {
+          return {
+            hiddenMenu: val
+          };
+        });
+      },
+      selectedNode: null,
+      setSelectedNode: function setSelectedNode(val) {
+        return set(function () {
+          return {
+            selectedNode: val
+          };
+        });
+      },
+      variableTree: [],
+      setVariableTree: function setVariableTree(val) {
+        return set(function () {
+          return {
+            variableTree: val
+          };
+        });
+      },
+      checkList: [],
+      setCheckList: function setCheckList(val) {
+        return set(function () {
+          return {
+            checkList: val
+          };
+        });
+      },
+      nodeSchemaMap: {},
+      setNodeSchema: function setNodeSchema(val) {
+        return set(function () {
+          return {
+            nodeSchemaMap: val
+          };
+        });
+      },
+      slots: {},
+      onChange: function onChange() {},
+      showSingleTest: false,
+      setShowSingleTest: function setShowSingleTest(val) {
+        return set(function () {
+          return {
+            showSingleTest: val
+          };
+        });
+      },
+      onAddCustomNode: function onAddCustomNode() {
+        return Promise.resolve(null);
+      },
+      showMiniMap: false,
+      setShowMiniMap: function setShowMiniMap(val) {
+        return set(function () {
+          return {
+            showMiniMap: val
+          };
+        });
+      },
+      futureSteps: [],
+      setFutureSteps: function setFutureSteps(val) {
+        return set(function () {
+          return {
+            futureSteps: val
+          };
+        });
+      },
+      historySteps: [],
+      setHistorySteps: function setHistorySteps(val) {
+        return set(function () {
+          return {
+            historySteps: val
+          };
+        });
+      },
+      minMaxZoom: [0.1, 2],
+      interactiveMode: localStorage.getItem('spark-flow-interactive-mode') || 'mouse',
+      setInteractiveMode: function setInteractiveMode(val) {
+        localStorage.setItem('spark-flow-interactive-mode', val);
+        set(function () {
+          return {
+            interactiveMode: val
+          };
+        });
+      },
+      isDragging: false,
+      setIsDragging: function setIsDragging(val) {
+        return set(function () {
+          return {
+            isDragging: val
+          };
+        });
+      },
+      showCheckList: false,
+      setShowCheckList: function setShowCheckList(val) {
+        return set(function () {
+          return {
+            showCheckList: val
+          };
+        });
+      },
+      debounceChangeTimeout: 300
+    }, initialState);
+  });
+};

package/dist/tailwind.css

@@ -0,0 +1,28 @@
+
+/* 不引入 base (reset) 样式，避免与项目现有样式冲突 */
+
+/* @tailwind base; */
+@tailwind components;
+@tailwind utilities;
+
+@layer components {
+  .flex-justify-between {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+  }
+
+  .flex-center {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+
+  .full-center {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+}

package/dist/types/work-flow.d.ts

@@ -0,0 +1,188 @@
+import { IVarTreeItem } from "../components/variable-tree-select";
+import { SparkIconProps } from '@agentscope-ai/icons/src/utils';
+import { Node } from '@xyflow/react';
+import { ReactNode } from 'react';
+export type INodeProps = {
+    id: string;
+    data: IWorkFlowNodeData;
+};
+export interface INodeSchema {
+    type: string;
+    iconType: (props: SparkIconProps) => ReactNode;
+    title: string;
+    desc: string;
+    defaultParams: Omit<IWorkFlowNodeData, 'label'>;
+    isSystem?: boolean;
+    allowSingleTest?: boolean;
+    allowSourceNodeTypes?: string[];
+    allowTargetNodeTypes?: string[];
+    disableConnectSource?: boolean;
+    disableConnectTarget?: boolean;
+    defaultHeight?: number;
+    checkValid?: (data: IWorkFlowNodeData) => {
+        label: string;
+        error: string;
+    }[];
+    getRefVariables?: (data: IWorkFlowNodeData) => string[];
+    getParentNodeVariableList?: (data: IWorkFlowNode, options?: {
+        disableShowVariableParameters?: boolean;
+    }) => IVarTreeItem[];
+    groupLabel?: string;
+    bgColor: string;
+    customAdd?: boolean;
+    hideInMenu?: boolean;
+    /** Whether configuration is prohibited */
+    notAllowConfig?: boolean;
+    /** Whether it is a group node */
+    isGroup?: boolean;
+    /** Whether it is prohibited to appear on group nodes, if is a string array, it means the node type is prohibited to appear on the specified group nodes */
+    disableInGroup?: boolean | string[];
+}
+export interface IPointItem {
+    type: string;
+    id: string;
+    handleId: string;
+}
+export interface IEdgeData {
+    _hover?: boolean;
+    _source_node_status?: IWorkFlowStatus;
+    _target_node_status?: IWorkFlowStatus;
+}
+export interface INodeDataOutputParamItem {
+    id?: string;
+    key: string;
+    type?: IValueType;
+    desc?: string;
+    required?: boolean;
+    value_from?: 'refer' | 'input' | 'clear';
+    properties?: INodeDataOutputParamItem[];
+}
+export interface INodeDataInputParamItem {
+    id?: string;
+    key: string;
+    type?: IValueType;
+    value?: string;
+    value_from?: 'refer' | 'input' | 'clear';
+    /** Whether the parameter is required */
+    required?: boolean;
+}
+export type IWorkFlowNodeData<T = any> = {
+    label: string;
+    input_params: INodeDataInputParamItem[];
+    output_params: INodeDataOutputParamItem[];
+    node_param: T;
+    desc?: string;
+};
+export interface IConditionItem {
+    operator?: string;
+    left: Omit<INodeDataInputParamItem, 'key'>;
+    right: Omit<INodeDataInputParamItem, 'key'>;
+}
+export interface IBranchItem {
+    id: string;
+    label: string;
+    logic?: 'and' | 'or';
+    conditions?: IConditionItem[];
+}
+export interface ICheckListItem {
+    node_id: string;
+    node_type: string;
+    node_name: string;
+    error_msgs: {
+        label: string;
+        error: string;
+    }[];
+}
+export interface IWorkFlowNode extends Node<IWorkFlowNodeData> {
+    type: string;
+}
+export type IValueType = 'Array<Object>' | 'Array<File>' | 'Array<String>' | 'Array<Number>' | 'Array<Boolean>' | 'Object' | 'File' | 'String' | 'Number' | 'Boolean';
+export type IValueTypeOption = {
+    label: string;
+    value: IValueType | 'Array';
+    disabled?: boolean;
+    children?: IValueTypeOption[];
+};
+export type IWorkFlowStatus = 'wait' | 'success' | 'fail' | 'skip' | 'executing' | 'stop';
+export interface IUserInputItem {
+    key: string;
+    type: IValueType;
+    desc: string;
+    value?: string;
+    required?: boolean;
+}
+export interface IWorkFlowTaskResultItem {
+    node_type: string;
+    node_name: string;
+    node_id: string;
+    node_content: string | IUserInputItem[];
+    node_status: IWorkFlowStatus;
+    parent_node_id?: string;
+}
+export interface IWorkFlowNodeResultItem {
+    is_batch: boolean;
+    retry?: {
+        happened: boolean;
+        retry_times: number;
+    };
+    input?: string;
+    output?: string;
+    usages?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    }[];
+    batches: IWorkFlowNodeResultItem[];
+    is_multi_branch: boolean;
+    multi_branch_results?: {
+        condition_id: string;
+        target_ids: string[];
+    }[];
+    node_id: string;
+    node_name: string;
+    node_type: string;
+    node_status: IWorkFlowStatus;
+    parent_node_id?: string;
+    output_type: 'json' | 'text';
+    node_exec_time: string;
+    try_catch?: {
+        happened: boolean;
+        strategy: string;
+    };
+    short_memory?: {
+        round: number;
+        current_self_chat_messages: {
+            role?: string;
+            content?: any;
+            name?: string;
+            tool_calls?: Array<{
+                id: string;
+                type: string;
+                index: number;
+                function: {
+                    name: string;
+                    arguments: string;
+                    outputs: string;
+                };
+            }>;
+            audio?: {
+                id: string;
+                data: string;
+                expires_at: number;
+                transcript: string;
+            };
+        }[];
+    };
+    error_info?: string;
+}
+export interface IWorkFlowTaskProcess {
+    task_id: string;
+    conversation_id?: string;
+    request_id: string;
+    task_status: IWorkFlowStatus;
+    task_results: IWorkFlowTaskResultItem[];
+    error_code?: string;
+    error_info?: string;
+    task_exec_time: string;
+    node_results: IWorkFlowNodeResultItem[];
+}

package/dist/types/work-flow.js

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

package/dist/utils/default-values.d.ts

@@ -0,0 +1,2 @@
+import { IValueType } from "../types/work-flow";
+export declare const defaultValueMap: Record<IValueType, string>;

package/dist/utils/default-values.js

@@ -0,0 +1,16 @@
+export var defaultValueMap = {
+  String: '',
+  Number: '0',
+  Boolean: 'false',
+  Object: JSON.stringify({
+    key: 'value'
+  }, null, 2),
+  File: '',
+  'Array<Object>': JSON.stringify([{
+    key: 'value'
+  }], null, 2),
+  'Array<String>': JSON.stringify([''], null, 2),
+  'Array<Number>': JSON.stringify([0], null, 2),
+  'Array<Boolean>': JSON.stringify([false], null, 2),
+  'Array<File>': JSON.stringify([], null, 2)
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,39 @@
+import { IVarItem } from "../components/variable-tree-select";
+import { IWorkFlowNode } from "../types/work-flow";
+import { Connection, Edge, Node } from '@xyflow/react';
+export declare const generateEdge: (connection: Connection, isParent?: boolean) => {
+    id: string;
+    type: string;
+    source: string;
+    target: string;
+    sourceHandle: string | null;
+    targetHandle: string | null;
+    zIndex: number;
+    data: {};
+};
+export declare function splitAtFirstDigit(str: string): string[];
+export declare const generateUniqueName: (name: string, names: string[]) => string;
+export declare const getTypeFromId: (source: string) => string;
+export declare function isMacOS(): boolean;
+export declare const MAC_KEY_MAP: {
+    ctrl: string;
+};
+export declare function transformToMacKey(key: keyof typeof MAC_KEY_MAP): string;
+export declare function extractVariables(text: string, saveFormat?: boolean): string[];
+export declare const getIteratorNodeSize: (childrenNodes: Node[]) => {
+    width: number;
+    height: number;
+};
+export declare const layoutFlow: ({ nodes, edges, isSubFlow, }: {
+    nodes: Node[];
+    edges: Edge[];
+    isSubFlow?: boolean | undefined;
+}) => Promise<{
+    layoutedNodes: Node[];
+}>;
+export declare const getParentInputParams: (node: IWorkFlowNode) => IVarItem[];
+export declare const copyNodeConfig: (node: IWorkFlowNode, nodes: IWorkFlowNode[]) => IWorkFlowNode;
+export declare const copySubFlowNodeConfig: (node: IWorkFlowNode, nodes: IWorkFlowNode[]) => IWorkFlowNode;
+export declare const isEventInInput: (event: KeyboardEvent) => boolean;
+export declare const setWorkFlowLanguage: (language: string) => void;
+export declare const matchVariableFromVarItem: (variable: string, varItems: IVarItem[]) => IVarItem | undefined;