@shenghuabi/workflow 1.0.0

package/index.mjs

@@ -0,0 +1,2035 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/workflow/workflow-parser.service.ts
+import {
+  computed as computed3,
+  createInjector,
+  inject as inject4,
+  InjectionToken as InjectionToken2,
+  Injector as Injector2
+} from "static-injector";
+import Graph from "graphology";
+import {
+  getConnectedEdges,
+  getIncomers,
+  getOutgoers
+} from "@xyflow/react";
+
+// packages/workflow/share/workflow.const.ts
+var WorkflowNodeType = /* @__PURE__ */ ((WorkflowNodeType2) => {
+  WorkflowNodeType2["iteration"] = "iteration";
+  WorkflowNodeType2["iterationStart"] = "iteration-start";
+  WorkflowNodeType2["inputParams"] = "input-params";
+  WorkflowNodeType2["serialize"] = "serialize";
+  WorkflowNodeType2["parameters"] = "parameters";
+  WorkflowNodeType2["inlineInputItem"] = "inlineInputItem";
+  return WorkflowNodeType2;
+})(WorkflowNodeType || {});
+
+// packages/workflow/workflow-parser.service.ts
+import { uniqBy as uniqBy3 } from "es-toolkit";
+
+// packages/workflow/share/handle-node.ts
+function flatFilterHandleList(list) {
+  if (!list) {
+    return [];
+  }
+  return list.flat().filter(Boolean);
+}
+
+// packages/workflow/inline/inline.service.ts
+var InlineNodeService = class {
+  inlineList = [];
+  register(obj) {
+    Object.values(obj).forEach((item) => {
+      this.inlineList.push(item);
+    });
+  }
+  getInlineList() {
+    return this.inlineList;
+  }
+  conditionNodeList() {
+    return this.inlineList.filter((item) => item.nodeMode === "condition").reduce(
+      (obj, item) => {
+        obj[item.type] = true;
+        return obj;
+      },
+      {}
+    );
+  }
+  // todo 类型
+  getNodeRunner(type) {
+    return this.inlineList.find((item) => item.type === type)?.runner;
+  }
+};
+
+// packages/workflow/plugin/plugin.service.ts
+import { computed, signal } from "static-injector";
+var WorkflowPluginService = class {
+  nodeList = signal([]);
+  setNodeObject(obj) {
+    this.nodeList.set(obj);
+  }
+  conditionNodeList$$ = computed(
+    () => this.nodeList().filter((item) => item.nodeMode === "condition").reduce(
+      (obj, item) => {
+        obj[item.type] = true;
+        return obj;
+      },
+      {}
+    )
+  );
+  // todo 类型
+  getNodeRunner(type) {
+    return this.nodeList().find((item) => item.type === type).runner;
+  }
+};
+
+// packages/workflow/inline/node/index.node.ts
+var index_node_exports = {};
+__export(index_node_exports, {
+  ChatMainConfig: () => ChatMainConfig,
+  TextMainConfig: () => TextMainConfig
+});
+
+// packages/workflow/share/const.ts
+var DEFAULT_INPUT_KEY = `[INPUT]`;
+var HelpObj = {
+  templateVarLine: `- 变量定义格式: {{xx}},{{xx.yy}}`,
+  pathTodoLine: `- **TODO** 接收传入路径而不是指定`
+};
+
+// packages/workflow/share/util.ts
+import { v5 } from "uuid";
+var UUID_NS = "404cfae8-94e7-41a6-acec-1037dd1fdaad";
+function generateHandle(value, label = value) {
+  return { id: v5(value, UUID_NS), label, value };
+}
+
+// packages/workflow/share/common/examples.define.ts
+import {
+  condition,
+  patchWrappers,
+  renderConfig,
+  topClass
+} from "@piying/view-angular-core";
+import * as v from "valibot";
+
+// packages/workflow/share/util/layout.ts
+import { componentClass } from "@piying/view-angular-core";
+function asColumn() {
+  return componentClass("grid gap-2");
+}
+
+// packages/workflow/share/common/examples.define.ts
+var EXAMPLES_DEFINE = v.pipe(
+  v.optional(
+    v.array(
+      v.pipe(
+        v.object({
+          input: v.pipe(
+            v.object({
+              format: v.pipe(
+                v.optional(v.boolean(), false),
+                v.description(
+                  "选中后会尝试使用yaml解析为对象,再序列化为对应的响应类型"
+                ),
+                patchWrappers(["tooltip"])
+              ),
+              value: v.pipe(v.string(), v.title("问题"), topClass("flex-1"))
+            }),
+            // todo 待修复
+            topClass("flex gap-2 items-center")
+          ),
+          output: v.pipe(
+            v.object({
+              format: v.pipe(
+                v.optional(v.boolean(), false),
+                v.description("是否需要格式化"),
+                patchWrappers(["tooltip"])
+              ),
+              value: v.pipe(v.string(), v.title("回答"), topClass("flex-1"))
+            }),
+            topClass("flex gap-2 items-center")
+          )
+        }),
+        asColumn()
+      )
+    ),
+    []
+  ),
+  v.title("用例"),
+  v.description("回答问题之前,会参考定义的用例格式进行回复,用于规范回答"),
+  condition({
+    environments: ["display"],
+    actions: [
+      renderConfig({
+        hidden: true
+      })
+    ]
+  })
+);
+
+// packages/workflow/share/common/handle.define.ts
+import * as v2 from "valibot";
+import { renderConfig as renderConfig2, setComponent } from "@piying/view-angular-core";
+import { condition as condition2 } from "@piying/valibot-visit";
+var HiddenAction = condition2({
+  environments: ["display", "default"],
+  actions: [setComponent(""), renderConfig2({ hidden: true })]
+});
+var AnyHiddenList = v2.pipe(
+  v2.array(v2.pipe(v2.optional(v2.any()), HiddenAction)),
+  setComponent(""),
+  renderConfig2({ hidden: true })
+);
+var HandleDataDefine = v2.pipe(
+  v2.optional(
+    v2.object({
+      output: AnyHiddenList,
+      input: AnyHiddenList
+    })
+  ),
+  HiddenAction
+);
+
+// packages/workflow/share/common/inline-template.define.ts
+import {
+  componentClass as componentClass2,
+  disableWhen,
+  setWrappers,
+  topClass as topClass2
+} from "@piying/view-angular-core";
+import { map } from "rxjs";
+import * as v3 from "valibot";
+var INLINE_Template = v3.pipe(
+  v3.object({
+    enable: v3.optional(v3.boolean(), true),
+    // 经用条件
+    value: v3.pipe(
+      v3.optional(v3.string(), "{{NODE.description}}"),
+      v3.title("模板"),
+      v3.description("允许使用变量:{{NODE.xxx}}(参考节点帮助)"),
+      setWrappers(["tooltip", "form-field"]),
+      topClass2("flex-1"),
+      disableWhen({
+        listen: (fn) => fn({
+          list: [["..", "enable"]]
+        }).pipe(map(({ list }) => !list[0]))
+      })
+    )
+  }),
+  componentClass2("flex gap-2")
+);
+var INLINE_Template2 = v3.pipe(
+  v3.object({
+    enable: v3.optional(v3.boolean(), false),
+    // 经用条件
+    value: v3.pipe(
+      v3.optional(v3.string()),
+      v3.title("模板"),
+      v3.description("允许使用变量:{{ENTRY.xxx}}(参考节点帮助)"),
+      setWrappers(["tooltip", "form-field"]),
+      topClass2("flex-1"),
+      disableWhen({
+        listen: (fn) => fn({
+          list: [["..", "enable"]]
+        }).pipe(map(({ list }) => !list[0]))
+      })
+    )
+  }),
+  componentClass2("flex gap-2 items-center")
+);
+
+// packages/workflow/share/common/llm.define.ts
+import {
+  asVirtualGroup,
+  patchAsyncInputs,
+  setComponent as setComponent2
+} from "@piying/view-angular-core";
+import { condition as condition3 } from "@piying/valibot-visit";
+import * as v4 from "valibot";
+function llmModelConfig(item) {
+  return v4.pipe(
+    v4.intersect([
+      v4.pipe(
+        v4.intersect([
+          v4.pipe(
+            v4.object({
+              name: v4.pipe(
+                v4.optional(v4.string()),
+                v4.title("预定义模型配置"),
+                setComponent2("select"),
+                patchAsyncInputs({
+                  options: (field) => field.context.getModelList()
+                })
+              ),
+              model: v4.pipe(v4.optional(v4.string()), v4.title("模型")),
+              // todo 配置变化configuration层被去掉.这里应该更详细支持更多参数
+              baseURL: v4.pipe(v4.optional(v4.string()), v4.title("地址"))
+            }),
+            asColumn()
+          )
+        ]),
+        v4.title(item?.label ?? "对话模型"),
+        condition3({
+          environments: ["display", "config"],
+          actions: [asVirtualGroup()]
+        })
+      )
+    ]),
+    condition3({
+      environments: ["display", "config"],
+      actions: [asVirtualGroup()]
+    }),
+    setComponent2("accordion")
+  );
+}
+
+// packages/workflow/share/common/const.ts
+var DEFAULT_CHAT_SCHEMA_KEY = `[JsonSchema]`;
+var RUNNER_ORIGIN_OUTPUT_KEY = `[Origin]`;
+
+// packages/workflow/share/type2.ts
+import { v4 as v42 } from "uuid";
+import * as v6 from "valibot";
+var extraData = v6.looseObject({
+  references: v6.optional(v6.array(v6.custom(Boolean)))
+});
+var baseDataDefine = v6.object({
+  node: v6.object({ type: v6.string(), id: v6.string() }),
+  nodeResult: v6.pipe(v6.optional(v6.boolean(), false)),
+  dataId: v6.optional(v6.string(), () => v42()),
+  extra: v6.optional(extraData)
+});
+var CommonDataDefine = v6.object({
+  ...baseDataDefine.entries,
+  value: v6.any()
+});
+var LLMDataDefine = v6.object({
+  ...baseDataDefine.entries,
+  type: v6.optional(v6.literal("chat-stream"), "chat-stream"),
+  // 用来进行普通查询
+  value: v6.string(),
+  extra: v6.object({
+    ...extraData.entries,
+    content: v6.string(),
+    thinkContent: v6.optional(v6.string()),
+    isThinking: v6.optional(v6.boolean()),
+    delta: v6.string(),
+    historyList: v6.custom(Boolean)
+  })
+});
+function createLLMData(data) {
+  return v6.parse(LLMDataDefine, data);
+}
+function createResultData(data) {
+  const result = v6.parse(CommonDataDefine, data);
+  result.nodeResult = true;
+  return result;
+}
+function isChatStream(data) {
+  return !!data.extra && "content" in data.extra && "thinkContent" in data.extra;
+}
+
+// packages/workflow/share/workflow.emit.ts
+var WorkflowEmitter = class {
+  #ob;
+  setObserver(ob) {
+    this.#ob = ob;
+  }
+  getObserver() {
+    return this.#ob;
+  }
+  createLLMData = createLLMData;
+  send(data) {
+    if (this.#ob) {
+      this.#ob.next(data);
+    }
+  }
+};
+
+// packages/workflow/inline/node/chat/common.ts
+var NODE_COMMON = {
+  priority: -100,
+  type: "chat",
+  label: `对话`,
+  icon: { fontIcon: "chat" },
+  disableHead: false,
+  disableConnect: false,
+  color: "accent",
+  help: [
+    `- 点击输入框左侧图标可以切换或添加新行`,
+    `${HelpObj.templateVarLine}`,
+    "### 指定类型输出",
+    "- `JsonSchema`为可选输入,需要使用`代码`节点生成",
+    "> 设置后响应类型会自动变为json",
+    "> 也可以使用任何符合`ChatJsonSchema`类型的数据结构传入(`代码`节点编辑时有声明)",
+    "- 原始输出: 不进行任何格式化处理的输出",
+    "### 定义图片变量",
+    "- 只有支持图片传入的大语言模型才支持此选项",
+    "> 如`minicpm-v:8b`",
+    "- 定义后在对话中可以传入图片",
+    "- 或者可以使用`图片输入`节点手动指定一张图片",
+    "- 只有`用户提示词`可以使用图片输入",
+    "> 不清楚是否所有模型都遵循此规则,所以并没有限制输入"
+  ].join("\n"),
+  // config: defineConfig,
+  inputs: [
+    [],
+    [
+      {
+        label: "JsonSchema",
+        value: DEFAULT_CHAT_SCHEMA_KEY,
+        inputType: "schema",
+        optional: true
+      }
+    ]
+  ],
+  outputs: [[{ label: "原始输出", value: RUNNER_ORIGIN_OUTPUT_KEY }]]
+};
+
+// packages/workflow/inline/node/chat/chat.node.define.ts
+import * as v7 from "valibot";
+import {
+  componentClass as componentClass3,
+  condition as condition4,
+  patchInputs,
+  setComponent as setComponent3,
+  valueChange
+} from "@piying/view-angular-core";
+var ResponseList = ["json", "markdown", "yaml"];
+var ResponseFormat = ["text", "json_object", "json_schema"];
+var CHAT_NODE_DEFINE = v7.looseObject({
+  data: v7.looseObject({
+    config: v7.pipe(
+      v7.object({
+        llm: v7.optional(llmModelConfig()),
+        /** 处理时解析 */
+        responseFormat: v7.pipe(
+          v7.optional(v7.picklist(ResponseFormat)),
+          patchInputs({
+            options: [
+              // 有输入json时
+              {
+                label: "自动",
+                value: void 0,
+                description: `传入JsonSchema时为[json_schema],否则为[text]`
+              },
+              { label: "文本", value: "text" },
+              {
+                label: "JSON对象",
+                value: "json_object",
+                description: "只限制返回类型为JSON对象,不对字段进行限制"
+              },
+              {
+                label: "JSON格式定义",
+                value: "json_schema",
+                description: "限制返回类型为JSON对象,同时限制字段,不建议手动指定,传入JsonSchema后自动启用"
+              }
+            ]
+          }),
+          v7.title("响应格式")
+        ),
+        /** 处理后解析 */
+        parseBy: v7.pipe(
+          v7.optional(v7.picklist(ResponseList)),
+          patchInputs({
+            options: [
+              { label: "直接返回", value: void 0 },
+              {
+                label: "json",
+                value: "json",
+                description: `将返回的json代码块内容或原始内容解析为对象`
+              },
+              {
+                label: "markdown",
+                value: "markdown",
+                description: `[需要提示词约束]将返回其中的markdown代码块内容或原始内容`
+              },
+              {
+                label: "yaml",
+                value: "yaml",
+                description: `[需要提示词约束]将返回的yaml代码块内容或原始内容解析为对象`
+              }
+            ]
+          }),
+          v7.title("返回解析"),
+          valueChange((fn) => {
+            fn({ list: [["..", "responseFormat"]] }).subscribe(
+              ({ list: [value], field }) => {
+                if ((value ?? "").startsWith("json")) {
+                  if (!field.form.control.value) {
+                    field.form.control.updateValue("json");
+                  }
+                }
+              }
+            );
+          })
+        ),
+        examples: EXAMPLES_DEFINE
+      }),
+      componentClass3("grid auto-rows-auto gap-2")
+    ),
+    value: v7.pipe(
+      v7.custom(Boolean),
+      setComponent3(""),
+      condition4({
+        environments: ["display"],
+        actions: [
+          setComponent3("prompt-list"),
+          valueChange((fn) => {
+            fn({ list: [void 0] }).subscribe(({ list: [value], field }) => {
+              if (!Array.isArray(value)) {
+                return;
+              }
+              const inputValue = value ?? [];
+              field.context.parseTemplate(
+                inputValue.flatMap(
+                  (item) => item.content.map(
+                    (item2) => item2.type === "text" ? item2.text : ""
+                  )
+                )
+              ).then((value2) => {
+                if (!value2) {
+                  return;
+                }
+                field.context.changeHandleData(field, "input", 1, value2);
+              });
+              const list = inputValue.flatMap(
+                (item) => item.content.map(
+                  (item2) => item2.type === "image_url" ? item2.image_url.url : void 0
+                )
+              ).filter(Boolean).map((item) => ({
+                value: `${item}`,
+                label: `${item}`,
+                inputType: `image`
+              }));
+              field.context.changeHandleData(field, "input", 3, list ?? []);
+            });
+          })
+        ]
+      })
+    )
+  })
+});
+
+// packages/workflow/inline/node/chat/main/llm.runner.ts
+import { inject as inject2 } from "static-injector";
+import { parse as parse2 } from "yaml";
+import { uniqBy as uniqBy2 } from "es-toolkit";
+
+// packages/openai/chat/util/create.ts
+function createAssistantMessage(text = "") {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }]
+  };
+}
+
+// packages/workflow/inline/node/chat/main/llm.runner.ts
+import { LogService } from "@cyia/external-call";
+
+// packages/workflow/runner/runner-item.ts
+import { computed as computed2, inject, Injector } from "static-injector";
+
+// packages/workflow/token.ts
+import { InjectionToken } from "static-injector";
+var CurrentWorkflowToken = new InjectionToken(
+  "CurrentWorkflow"
+);
+var InputsToken = new InjectionToken("Input");
+var CurrentNodeToken = new InjectionToken("CurrentNode");
+var CurrentCallNodeToken = new InjectionToken(
+  "CurrentCallNode"
+);
+var CurrentContextToken = new InjectionToken(
+  "CurrentContext"
+);
+var InputParamsToken = new InjectionToken(
+  "InputParams"
+);
+var ParentContextToken = new InjectionToken("ParentContext");
+var UseInputToken = new InjectionToken("UseInput");
+var AbortSignalToken = new InjectionToken(
+  "AbortSignal"
+);
+var EnviromentParametersToken = new InjectionToken("EnviromentParameters");
+var ModelOptionsToken = new InjectionToken(
+  "ModelOptions"
+);
+var WorkflowConfigToken = new InjectionToken("WorkflowConfig");
+var ChatServiceToken = new InjectionToken("ChatServiceToken");
+
+// packages/workflow/runner/runner-item.ts
+import * as v8 from "valibot";
+import { isEmptyInput, isStringArray } from "@cyia/util";
+import { omitBy } from "es-toolkit";
+import { defaultsDeep } from "es-toolkit/compat";
+var NodeRunnerBase = class {
+  node = inject(CurrentNodeToken);
+  callNode = inject(CurrentCallNodeToken);
+  context = inject(CurrentContextToken);
+  // protected useInput = inject(UseInputToken);
+  inputParams = inject(InputParamsToken);
+  injector = inject(Injector);
+  emitter = inject(WorkflowEmitter);
+  abortSignal = inject(AbortSignalToken);
+  async run() {
+    throw new Error("待实现");
+  }
+  inputs$$ = computed2(() => {
+    const obj = {};
+    for (const input of this.node.inputs) {
+      if (!input.type) {
+        const data = this.inputParams.get(input.value);
+        if (!data) {
+          if (input.optional) {
+            continue;
+          } else {
+            throw new Error(`缺少输入参数: ${input.value}`);
+          }
+        }
+        obj[input.value] = data;
+      }
+    }
+    return obj;
+  });
+  inputValueObject$$ = computed2(
+    () => Object.entries(this.inputs$$()).reduce(
+      (obj, item) => {
+        obj[item[0]] = item[1].value;
+        return obj;
+      },
+      {}
+    )
+  );
+  inputMetadataList$$ = computed2(
+    () => Object.values(this.inputs$$()).map((item) => item.extra?.metadata)
+  );
+  getInputMetadata(input) {
+    return this.inputs$$()[input].extra?.metadata;
+  }
+  async getInputChat() {
+    const metadataList = [];
+    const obj = {};
+    const errorList = [];
+    for (const input of this.node.inputs) {
+      if (!input.type) {
+        const data = this.inputParams.get(input.value);
+        if (!data) {
+          if (input.optional) {
+            continue;
+          } else {
+            errorList.push(input.value);
+            continue;
+          }
+        }
+        if (input.inputType === "image") {
+          obj[input.value] = data?.value;
+        } else if (isStringArray(data?.value)) {
+          obj[input.value] = data.value.join("\n");
+        } else {
+          obj[input.value] = data?.value ?? "";
+        }
+        const extra = data?.extra;
+        if (extra) {
+          if (Array.isArray(extra)) {
+            for (const { metadata } of extra) {
+              if (!metadata) {
+                continue;
+              }
+              metadataList.push(metadata);
+            }
+          } else {
+            if (extra.metadata) {
+              metadataList.push(extra.metadata);
+            }
+          }
+        }
+      }
+    }
+    if (errorList.length) {
+      throw new Error(`缺少输入参数: ${errorList.join(",")}`);
+    }
+    return { metadataList, obj };
+  }
+  #modelConfig = inject(ModelOptionsToken);
+  mergeChatModel(input) {
+    let chatService = this.injector.get(ChatServiceToken);
+    let presetConfig = {};
+    if (input?.name) {
+      presetConfig = chatService.getModelConfig(input.name) ?? {};
+    }
+    return input ? defaultsDeep(
+      omitBy(
+        {
+          model: input.model,
+          baseURL: input?.baseURL
+        },
+        isEmptyInput
+      ),
+      omitBy(presetConfig, isEmptyInput),
+      omitBy(this.#modelConfig ?? {}, isEmptyInput)
+    ) : this.#modelConfig;
+  }
+  getParsedNode(schema) {
+    const result = v8.safeParse(schema, this.node);
+    if (result.success) {
+      return result.output;
+    }
+    if (!PROD_ENV) {
+      console.log(result.issues);
+    }
+    throw new Error(JSON.stringify(result.issues));
+  }
+};
+
+// packages/workflow/template-format.service.ts
+import hbs1 from "handlebars";
+import { RootStaticInjectOptions } from "static-injector";
+import { uniqBy } from "es-toolkit";
+import { Liquid } from "liquidjs";
+var engine = new Liquid({ jsTruthy: true });
+var TemplateFormatService = class extends RootStaticInjectOptions {
+  interpolate(input, value) {
+    return hbs1.compile(input, { noEscape: true, preventIndent: true })(value, {
+      allowProtoPropertiesByDefault: true
+    });
+  }
+  entryInterpolate(payload, knowledge, content, embedingTemplate) {
+    return embedingTemplate?.enable ? this.interpolate(embedingTemplate.value ?? "", {
+      ENTRY: { ...payload, knowledge }
+    }) : content;
+  }
+  /** 用于模板格式化 */
+  parse(input) {
+    let list;
+    try {
+      list = hbs1.parse(input).body;
+    } catch (error) {
+      return { list: [], error: true };
+    }
+    const result = this.#getActionInputVariable(list, /* @__PURE__ */ new Set());
+    return {
+      list: [...result.set].map((item) => {
+        if (result.object.has(item)) {
+          return { inputType: "object", value: item };
+        }
+        return { inputType: "string", value: item };
+      }),
+      error: false
+    };
+  }
+  // 只有条件用,没太大用途
+  async parserJs(input) {
+    const { createCssSelectorForTs } = await import("@cyia/code-util/selector/ts");
+    try {
+      const selector = createCssSelectorForTs(input, { scriptKind: 1 });
+      const objectList = selector.queryAll(
+        `:not(DotToken)+Identifier,*::children(0)[tag=Identifier]`
+      );
+      return {
+        list: uniqBy(objectList, (item) => item.value).map((item) => ({
+          inputType: "object",
+          value: item.value
+        })),
+        error: false
+      };
+    } catch (error) {
+      return {
+        error: true,
+        list: []
+      };
+    }
+  }
+  async parserLiquid(input) {
+    try {
+      const result = engine.parse(input);
+      const varList = /* @__PURE__ */ new Set();
+      const proxyObj = new Proxy(
+        {},
+        {
+          getOwnPropertyDescriptor(target, p) {
+            return void 0;
+          },
+          has(target, p) {
+            varList.add(p);
+            return true;
+          }
+        }
+      );
+      await engine.render(result, proxyObj);
+      return {
+        list: [...varList].map((item) => ({
+          inputType: "object",
+          value: item
+        })),
+        error: false
+      };
+    } catch (error) {
+      return { error: true, list: [] };
+    }
+  }
+  #getActionInputVariable(body, nowSet) {
+    const obj = {
+      set: /* @__PURE__ */ new Set(),
+      block: {},
+      object: /* @__PURE__ */ new Set()
+    };
+    for (const item of body) {
+      if (item.type === "MustacheStatement") {
+        if (item.path.type === "PathExpression") {
+          const path3 = item.path;
+          obj.set.add(path3.parts[0]);
+          if (path3.parts.length > 1) {
+            obj.object.add(path3.parts[0]);
+          }
+        } else {
+        }
+      } else {
+      }
+    }
+    return obj;
+  }
+};
+
+// packages/workflow/inline/node/chat/main/llm.runner.ts
+import { jsonParse, yamlParse, markdownParse, isChatSchema } from "@cyia/util";
+var LlmRunner = class extends NodeRunnerBase {
+  #format = inject2(TemplateFormatService);
+  #chatService = inject2(ChatServiceToken);
+  #abort = inject2(AbortSignalToken);
+  #channel = inject2(LogService).getToken("chat");
+  async run() {
+    const { metadataList, obj } = await this.getInputChat();
+    const inputJsonSchema = this.inputParams.get(DEFAULT_CHAT_SCHEMA_KEY);
+    const nodeResult = this.getParsedNode(CHAT_NODE_DEFINE);
+    const config = nodeResult.data.config;
+    const examples = config.examples;
+    const list = nodeResult.data.value;
+    const historyList = list.map((item) => {
+      const content = this.#format.interpolate(
+        item.content.map((item2) => item2.type === "text" ? item2.text : "").join("\n"),
+        obj
+      );
+      return {
+        role: item.role,
+        content: [
+          { type: "text", text: content },
+          ...item.content.filter((item2) => item2.type === "image_url").flatMap((item2) => {
+            if (item2.type === "image_url") {
+              return obj[item2.image_url.url].map((item3) => ({
+                type: "image_url",
+                image_url: { url: item3.data }
+              }));
+            }
+            return item2;
+          })
+        ]
+      };
+    });
+    const schema = isChatSchema(inputJsonSchema?.value);
+    if (inputJsonSchema?.value && !schema) {
+      throw new Error(
+        `JsonSchema传入格式异常,需要: {name:string,schema:object},传入: ${JSON.stringify(inputJsonSchema.value)}`
+      );
+    } else if (schema) {
+      config.parseBy ??= "json";
+      config.responseFormat ??= "json_schema";
+    }
+    if (examples.length) {
+      const examplesTemplate = examples.filter((item) => item.input.value && item.output.value).flatMap((item) => [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: this.#exampleFormat(item.input, config.parseBy)
+            }
+          ]
+        },
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "text",
+              text: this.#exampleFormat(item.output, config.parseBy)
+            }
+          ]
+        }
+      ]);
+      let index = historyList.findIndex((item) => item.role === "system");
+      index = index === -1 ? 0 : index + 1;
+      historyList.splice(index, 0, ...examplesTemplate);
+    }
+    this.#channel?.info("节点对话配置", config.llm);
+    const llm = await this.#chatService.chat(this.mergeChatModel(config.llm));
+    const result = await llm.stream(
+      {
+        messages: historyList,
+        response_format: config.responseFormat === "json_schema" ? { type: "json_schema", json_schema: inputJsonSchema?.value } : config.responseFormat === "json_object" ? { type: "json_object" } : void 0
+      },
+      { signal: this.#abort }
+    );
+    const streamData = createLLMData({
+      node: this.node,
+      value: "",
+      extra: {
+        references: uniqBy2(
+          metadataList,
+          (item) => item.type + item.description + item.tooltip || ""
+        ),
+        historyList: [],
+        delta: "",
+        content: ""
+      }
+    });
+    const endRef = this.#chatService.getMetadataEndRef(
+      streamData.extra.references
+    );
+    for await (const item of result) {
+      const value = endRef ? item.content + endRef : item.content;
+      streamData.value = value;
+      streamData.extra = { ...streamData.extra, ...item, content: value };
+      this.emitter.send(streamData);
+    }
+    const resultContent = streamData.value;
+    streamData.extra.delta = "";
+    historyList.push(createAssistantMessage(resultContent));
+    streamData.extra.historyList = historyList;
+    this.emitter.send(streamData);
+    return async (outputName) => {
+      if (outputName === RUNNER_ORIGIN_OUTPUT_KEY) {
+        return {
+          value: streamData.value,
+          dataId: streamData.dataId,
+          extra: streamData.extra
+        };
+      }
+      let value;
+      switch (config.parseBy) {
+        case "markdown":
+          value = markdownParse(resultContent);
+          break;
+        case "json":
+          value = jsonParse(resultContent);
+          break;
+        case "yaml":
+          value = yamlParse(resultContent);
+          break;
+        default:
+          value = resultContent;
+          break;
+      }
+      if (typeof value === "undefined") {
+        throw new Error(`解析${config.parseBy}失败`);
+      }
+      return { value, dataId: streamData.dataId, extra: streamData.extra };
+    };
+  }
+  #exampleFormat(data, format) {
+    if (data.format) {
+      if (format === "json") {
+        return JSON.stringify(parse2(data.value));
+      }
+      return data.value;
+    } else {
+      return data.value;
+    }
+  }
+};
+
+// packages/workflow/inline/node/chat/main/index.ts
+var ChatMainConfig = {
+  ...NODE_COMMON,
+  runner: LlmRunner,
+  define: CHAT_NODE_DEFINE
+};
+
+// packages/workflow/inline/node/text/common.ts
+var NODE_COMMON2 = {
+  type: "textarea",
+  label: `文本模板`,
+  icon: { fontIcon: "text_snippet" },
+  disableHead: false,
+  disableConnect: false,
+  color: "primary",
+  help: `${HelpObj.templateVarLine}`,
+  priority: -98
+};
+
+// packages/workflow/inline/node/text/main/textarea.runner.ts
+import { inject as inject3 } from "static-injector";
+var TextareaRunner = class extends NodeRunnerBase {
+  #format = inject3(TemplateFormatService);
+  async run() {
+    const obj = this.inputValueObject$$();
+    const str = this.node.data.value;
+    return async () => ({ value: this.#format.interpolate(str, obj) });
+  }
+};
+
+// packages/workflow/inline/node/text/main/index.ts
+var TextMainConfig = {
+  ...NODE_COMMON2,
+  runner: TextareaRunner
+};
+
+// packages/workflow/workflow-parser.service.ts
+var WorkflowParserContext = class _WorkflowParserContext {
+  constructor(list, subObject, data, parentNode, userInputParams = [], parent) {
+    this.list = list;
+    this.subObject = subObject;
+    this.data = data;
+    this.parentNode = parentNode;
+    this.userInputParams = userInputParams;
+    this.parent = parent;
+  }
+  list;
+  subObject;
+  data;
+  parentNode;
+  userInputParams;
+  parent;
+  // fixme 或许可以分离，单独调用，然后加上children查找，不过那样就太慢了
+  #childUseNodeSet = /* @__PURE__ */ new Set();
+  /** 只能子级在本级找不到节点时调用父级使用 */
+  childUseDefine(id, parentId) {
+    const define = this.list.find((item) => item.id === id);
+    if (!define) {
+      return this.parent?.childUseDefine(id, parentId);
+    }
+    if (id !== parentId) {
+      this.#childUseNodeSet.add(id);
+    }
+    return define;
+  }
+  #getParentNodeDefine(id) {
+    return this.parent?.childUseDefine(id, this.parentNode?.id);
+  }
+  parseItem() {
+    const graph = new Graph({ multi: true });
+    const { nodes, edges } = this.data.flow;
+    const nodeData = { nodes: {}, end: void 0 };
+    this.list.forEach((node) => {
+      graph.addNode(node.id);
+    });
+    for (const node of this.list) {
+      const handle = {
+        output: flatFilterHandleList(node.data.handle?.output)
+      };
+      const cEdges = getConnectedEdges([node], edges);
+      const inputNodes = getIncomers(node, nodes, cEdges);
+      const inputHandleList = flatFilterHandleList(node.data.handle?.input);
+      const inputParams = [];
+      for (const item of inputHandleList) {
+        const targetHandle = item.id;
+        const linkedEdges = cEdges.filter(
+          (item2) => item2.targetHandle === targetHandle && item2.target === node.id
+        );
+        if (linkedEdges.length > 1) {
+          return {
+            error: {
+              message: `${node.id}:不支持多个节点连接一个输入点`,
+              nodeId: node.id
+            }
+          };
+        }
+        if (linkedEdges.length === 1) {
+          const linkedEdge = linkedEdges[0];
+          const linkedNode = inputNodes.find(
+            (item2) => item2.id === linkedEdge.source
+          );
+          const linkedOuput = flatFilterHandleList(
+            linkedNode.data.handle?.output
+          ).find((item2) => item2.id === linkedEdge.sourceHandle);
+          inputParams.push({
+            ...item,
+            nodeId: linkedNode.id,
+            outputName: linkedOuput.value
+          });
+          if (!graph.hasNode(linkedNode.id)) {
+            if (!this.#getParentNodeDefine(linkedNode.id)) {
+              return {
+                error: {
+                  message: `${linkedNode.id}:未找到连接节点,只能读取到当前及祖先范围内的节点`,
+                  nodeId: linkedNode.id
+                }
+              };
+            }
+            graph.addNode(linkedNode.id);
+          }
+          graph.addEdge(linkedNode.id, node.id);
+        } else {
+          inputParams.push({ ...item });
+          if (item.type) {
+            continue;
+          }
+          this.userInputParams.push(item);
+        }
+      }
+      nodeData.nodes[node.id] = {
+        data: node.data,
+        //输入用
+        inputs: inputParams,
+        outputs: handle.output,
+        type: node.type,
+        id: node.id
+      };
+      if (this.subObject[node.id]) {
+        for (let index = 0; index < this.subObject[node.id].length; index++) {
+          const { key, startId, nodeList } = this.subObject[node.id][index];
+          const instance = new _WorkflowParserContext(
+            nodeList,
+            this.subObject,
+            this.data,
+            node,
+            this.userInputParams,
+            this
+          );
+          const result = instance.parseItem();
+          if (result.error) {
+            return { error: { ...result.error } };
+          }
+          nodeData.nodes[node.id].subFlowList ??= [];
+          nodeData.nodes[node.id].subFlowList.push({
+            key,
+            flow: result.data,
+            startId
+          });
+        }
+      }
+    }
+    const outList = [];
+    graph.forEachNode((node) => {
+      if (!this.#childUseNodeSet.has(node) && graph.outDegree(node) === 0) {
+        outList.push(node);
+      }
+    });
+    if (outList.length > 1) {
+      return { error: { message: `计算时存在多个出口` } };
+    } else if (outList.length === 0) {
+      return { error: { message: `可能出现循环依赖,没有出口` } };
+    } else {
+      nodeData.end = outList[0];
+      nodeData.inputList = uniqBy3(
+        this.userInputParams,
+        (item) => `${item.inputType || "string"}|${item.value}`
+      ).map((item) => ({
+        inputType: item.inputType || "string",
+        value: item.value,
+        label: item.label || item.value,
+        optional: item.optional
+      }));
+      return { data: nodeData };
+    }
+  }
+};
+var NodeGroup = class {
+  #group = /* @__PURE__ */ new Map();
+  #iterationMap = /* @__PURE__ */ new Map();
+  addContainerStart(node) {
+    this.#iterationMap.set(node.parentId, node);
+  }
+  getContainerStart(node) {
+    return this.#iterationMap.get(node.id);
+  }
+  add(node) {
+    const nodeMap = this.#group.get(node.type) || [];
+    nodeMap.push(node);
+    this.#group.set(node.type, nodeMap);
+  }
+  getList(type) {
+    return this.#group.get(type) || [];
+  }
+};
+var WorkflowDataToken = new InjectionToken2(
+  "WorkflowData"
+);
+var WorkflowPreParser = class {
+  /**
+   * 迭代块：直接找父级parentid就行了
+   * 分类块：所有后面的都算他的
+   * 重构，所有节点进行迭代
+   * 找迭代快，找到后找子级item块，找到后进行output查找+parent==迭代快
+   * 找分类，找到后output查找
+   * 所有独立块都是找到独立节点后终止
+   */
+  #nodeGroup = new NodeGroup();
+  #data = inject4(WorkflowDataToken);
+  #plugin = inject4(WorkflowPluginService);
+  #inlineNodeService = inject4(InlineNodeService);
+  #fullBlockObject$$ = computed3(
+    () => ({
+      ...this.#inlineNodeService.conditionNodeList(),
+      ...this.#plugin.conditionNodeList$$(),
+      ["iteration" /* iteration */]: true
+    })
+  );
+  #conditionBlockObject$$ = computed3(
+    () => ({
+      ...this.#inlineNodeService.conditionNodeList(),
+      ...this.#plugin.conditionNodeList$$()
+    })
+  );
+  parse() {
+    const { nodes, edges } = this.#data.flow;
+    const mainList = [];
+    const subObjectGroup = {};
+    const excludeSet = /* @__PURE__ */ new Set();
+    const isBlock = (item) => this.#fullBlockObject$$()[item.type];
+    const removedList = /* @__PURE__ */ new Set();
+    const getSubNode = (node, subNodeList) => {
+      subNodeList.push(node);
+      excludeSet.add(node.id);
+      if (!isBlock(node)) {
+        getOutgoers(node, nodes, edges).forEach((item) => {
+          getSubNode(item, subNodeList);
+        });
+      }
+    };
+    let manualInput = false;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.data.excludeUsage) {
+        removedList.add(node.id);
+        nodes.splice(i, 1);
+        i--;
+        continue;
+      }
+      if (node.type === "input-params") {
+        manualInput ||= !!node.data.config?.["manualInput"];
+      } else if (isBlock(node)) {
+        this.#nodeGroup.add(node);
+      } else if (node.type === "iteration-start" /* iterationStart */) {
+        this.#nodeGroup.addContainerStart(node);
+      }
+    }
+    Object.keys(this.#fullBlockObject$$()).flatMap((key) => this.#nodeGroup.getList(key)).forEach((node) => {
+      const outputList = subObjectGroup[node.id] || [];
+      subObjectGroup[node.id] = outputList;
+      if (node.type === "iteration" /* iteration */) {
+        const subNodeList = [];
+        const startNode = this.#nodeGroup.getContainerStart(node);
+        getSubNode(startNode, subNodeList);
+        outputList.push({
+          nodeList: uniqBy3(subNodeList, (item) => item.id),
+          startId: startNode.id,
+          key: `[default]`
+        });
+      } else if (this.#conditionBlockObject$$()[node.type]) {
+        const cEdges = getConnectedEdges([node], edges);
+        const children = getOutgoers(node, nodes, cEdges);
+        const outputHandleList = flatFilterHandleList(
+          node.data.handle.output
+        );
+        for (const outputHandle of outputHandleList) {
+          const outputEdgeList = cEdges.filter(
+            (edge) => edge.sourceHandle === outputHandle.id
+          );
+          if (!outputEdgeList.length) {
+            throw new Error(`[${node.data.title || ""}]节点上发现未连接出口`);
+          }
+          for (const childNode of children.filter(
+            ({ id }) => outputEdgeList.some(({ target }) => target === id)
+          )) {
+            const subNodeList = [];
+            getSubNode(childNode, subNodeList);
+            outputList.push({
+              nodeList: uniqBy3(subNodeList, (item) => item.id),
+              startId: childNode.id,
+              key: outputHandle.value
+            });
+          }
+        }
+      }
+    });
+    for (const node of nodes) {
+      if (excludeSet.has(node.id)) {
+        continue;
+      }
+      mainList.push(node);
+    }
+    return {
+      list: mainList,
+      subObjectGroup,
+      manualInput,
+      edges: edges.filter(
+        (edge) => !removedList.has(edge.source) && !removedList.has(edge.target)
+      )
+    };
+  }
+};
+var WorkflowParserService = class {
+  #injector = inject4(Injector2);
+  #inlineNode = inject4(InlineNodeService);
+  constructor() {
+    this.#inlineNode.register(index_node_exports);
+  }
+  /**
+   * 1.如果出现孤立节点，那么需要判断是不是子级引用
+   * 2.子级引用本级别找不到，那么需要找父级
+   */
+  /**
+   * 边有id,通过source 找到连接的节点
+   *
+   */
+  parse(data) {
+    const injector = createInjector({
+      providers: [
+        WorkflowPreParser,
+        { provide: WorkflowDataToken, useValue: data }
+      ],
+      parent: this.#injector
+    });
+    const preInstance = injector.get(WorkflowPreParser);
+    const result = preInstance.parse();
+    if (!result.list.length) {
+      return {
+        error: {
+          message: "无可用节点"
+        }
+      };
+    }
+    const instance = new WorkflowParserContext(
+      result.list,
+      result.subObjectGroup,
+      { ...data, flow: { ...data.flow, edges: result.edges } }
+    );
+    return { ...instance.parseItem(), manualInput: result.manualInput };
+  }
+};
+
+// packages/workflow/workflow-exec.service.ts
+import { inject as inject11 } from "static-injector";
+
+// packages/workflow/preset/inline-runner.service.ts
+import { inject as inject9 } from "static-injector";
+
+// packages/workflow/preset/inline-build.service.ts
+import { inject as inject5 } from "static-injector";
+
+// packages/workflow/runner/parameters.runner.ts
+var ParametersRunner = class extends NodeRunnerBase {
+  static runnerName = "parameters";
+  async run() {
+    return async () => ({ value: this.inputs$$() });
+  }
+};
+
+// packages/workflow/preset/inline-build.service.ts
+var InlineBuilderService = class {
+  template = inject5(TemplateFormatService);
+  parser = inject5(WorkflowParserService);
+  #createLLMNode(input) {
+    return {
+      id: "1",
+      data: {
+        handle: {
+          input: [
+            Object.keys({ ...input.input, ...input.context }).map(
+              (value, i) => ({
+                id: `${i}`,
+                value,
+                label: ``
+              })
+            )
+          ],
+          output: [
+            [
+              {
+                id: "1",
+                label: "",
+                value: "输出"
+              }
+            ]
+          ]
+        }
+      },
+      type: ParametersRunner.runnerName
+    };
+  }
+  #createEdge(llmNode, context) {
+    const edgeList = [];
+    const addEdge = (node) => {
+      const inputHandleList = node.data.handle?.input.flat() || [];
+      for (const inputHandle of inputHandleList) {
+        const item = context[inputHandle.value];
+        if (!item) {
+          continue;
+        }
+        const sourceHandle = item.data.handle.output[0][0];
+        edgeList.push({
+          source: item.id,
+          sourceHandle: sourceHandle.id,
+          // 自身
+          target: node.id,
+          targetHandle: inputHandle.id
+        });
+      }
+    };
+    for (const ctxKey in context) {
+      const node = context[ctxKey];
+      addEdge(node);
+    }
+    addEdge(llmNode);
+    return edgeList;
+  }
+  #createWorkflow(input) {
+    const chatNode = this.#createLLMNode(input);
+    const edges = this.#createEdge(chatNode, input.context);
+    return {
+      nodes: [chatNode, ...Object.values(input.context)],
+      edges
+    };
+  }
+  createDefine(input) {
+    return this.parser.parse({ flow: this.#createWorkflow(input) });
+  }
+};
+
+// packages/workflow/runner/workflow-runner.service.ts
+import { createInjector as createInjector2, inject as inject8, Injector as Injector3 } from "static-injector";
+
+// packages/workflow/runner/inline-input-item.runner.ts
+import { inject as inject6 } from "static-injector";
+var InlineInputItemRunner = class extends NodeRunnerBase {
+  static runnerName = "inlineInputItem";
+  #env = inject6(EnviromentParametersToken);
+  async run() {
+    return async () => {
+      const key = this.node.inputs[0].value;
+      const result = this.#env;
+      if (!result) {
+        throw new Error(`读取上下文参数[${key}]失败`);
+      }
+      return { value: result[key] };
+    };
+  }
+};
+
+// packages/workflow/runner/input-params.runner.ts
+import { inject as inject7 } from "static-injector";
+var InputParamsRunner = class extends NodeRunnerBase {
+  #env = inject7(EnviromentParametersToken);
+  async run() {
+    return async () => {
+      const value = this.#env;
+      if (!value) {
+        throw new Error(`读取上下文失败`);
+      }
+      return {
+        value
+      };
+    };
+  }
+};
+
+// packages/workflow/runner/iteration-start.runner.ts
+var IterationStartRunner = class extends NodeRunnerBase {
+  async run() {
+    return async () => this.inputParams.get(ITERATION_ITEM_SYMBOL);
+  }
+};
+
+// packages/workflow/runner/iteration.runner.ts
+import { isIterable } from "@cyia/util";
+var IterationRunner = class extends NodeRunnerBase {
+  async run() {
+    const data = this.inputParams.get(this.node.inputs[0].value);
+    if (!data) {
+      throw new Error("输入节点为空");
+    }
+    const extra = data.extra;
+    const value = data.value;
+    if (!isIterable(value)) {
+      throw new Error(`输入值不是可迭代(数组)类型: ${JSON.stringify(value)}`);
+    }
+    const resultList = [];
+    let index = 0;
+    for (const item of value) {
+      const newInputs = new Map(this.inputParams);
+      newInputs.set(ITERATION_ITEM_SYMBOL, {
+        value: item,
+        extra: extra?.[index]
+      });
+      try {
+        resultList.push(
+          await this.injector.get(WorkflowRunnerService).createContext(
+            //迭代只有一个子流
+            this.node.subFlowList[0].flow,
+            newInputs,
+            this.context,
+            this.injector
+          ).run()
+        );
+      } catch (error) {
+        throw new Error(`执行第${index}出现异常`, { cause: error });
+      }
+      index++;
+    }
+    const list = resultList.reduce(
+      (obj, item) => {
+        obj.value.push(item.value);
+        obj.extra.push(item.extra);
+        return obj;
+      },
+      { value: [], extra: [] }
+    );
+    return async (outputName) => {
+      if (outputName === "flat") {
+        return { value: list.value.flat(999), extra: list.extra.flat(999) };
+      }
+      return list;
+    };
+  }
+};
+
+// packages/workflow/runner/define.ts
+var ItemRunnerObject = {
+  ["iteration" /* iteration */]: IterationRunner,
+  ["iteration-start" /* iterationStart */]: IterationStartRunner,
+  ["input-params" /* inputParams */]: InputParamsRunner,
+  ["parameters" /* parameters */]: ParametersRunner,
+  ["inlineInputItem" /* inlineInputItem */]: InlineInputItemRunner
+};
+
+// packages/workflow/runner/runner-error.ts
+var RunnerError = class _RunnerError extends Error {
+  #origin;
+  #list;
+  constructor(origin, list) {
+    super(
+      `${list.map(
+        (item) => `[${item.title}]${item.message ? ": " + item.message : ""}`
+      ).join("<-")}`,
+      { cause: origin }
+    );
+    this.#origin = origin;
+    this.#list = list;
+    delete this.stack;
+    this.name = `节点运行异常`;
+  }
+  create(item) {
+    this.#list.push(item);
+    return new _RunnerError(this.#origin, this.#list);
+  }
+};
+var AbortSignalError = class extends Error {
+};
+
+// packages/workflow/runner/workflow-runner.service.ts
+import { LogService as LogService2 } from "@cyia/external-call";
+var ITERATION_ITEM_SYMBOL = /* @__PURE__ */ Symbol("ITERATION_ITEM");
+var WorkflowRunnerContext = class {
+  #injector = inject8(Injector3);
+  data = inject8(CurrentWorkflowToken);
+  parent = inject8(ParentContextToken);
+  #callCache = /* @__PURE__ */ new Map();
+  #outputCache = /* @__PURE__ */ new Map();
+  inputs = inject8(InputsToken);
+  #plugin = inject8(WorkflowPluginService);
+  #emitter = inject8(WorkflowEmitter);
+  #inlineNode = inject8(InlineNodeService);
+  async #getNodeRunner(type) {
+    return this.#inlineNode.getNodeRunner(type) ?? ItemRunnerObject[type] ?? await this.#plugin.getNodeRunner(type);
+  }
+  getNodeById(id) {
+    const result = this.data.nodes[id];
+    if (!result) {
+      return this.parent?.getNodeById(id);
+    }
+    return result;
+  }
+  /** 调用缓存，同一个上下文内容不可能变化 */
+  #getCallCache(id) {
+    if (this.#callCache.has(id)) {
+      return { result: this.#callCache.get(id) };
+    }
+    return this.parent ? this.parent.#getCallCache(id) : void 0;
+  }
+  #getOuputCache(id) {
+    if (this.#outputCache.has(id)) {
+      return { result: this.#outputCache.get(id) };
+    }
+    return this.parent ? this.parent.#getOuputCache(id) : void 0;
+  }
+  async startRun() {
+    const node = this.getNodeById(this.data.end);
+    return this.#runItem(node);
+  }
+  async run() {
+    const node = this.getNodeById(this.data.end);
+    return this.#runItem(node);
+  }
+  // 当前node 调用 node context
+  async #createNodeRunner(item, inputParams, callNode, input) {
+    const define = await this.#getNodeRunner(item.type);
+    return createInjector2({
+      providers: [
+        define,
+        { provide: CurrentNodeToken, useValue: item },
+        { provide: CurrentCallNodeToken, useValue: callNode },
+        { provide: CurrentContextToken, useValue: this },
+        { provide: UseInputToken, useValue: input },
+        { provide: InputParamsToken, useValue: inputParams }
+      ],
+      parent: this.#injector
+    }).get(define);
+  }
+  #abort = inject8(AbortSignalToken);
+  async #runItem(node, callNode, input) {
+    try {
+      if (this.#abort?.aborted) {
+        throw new AbortSignalError();
+      }
+      const inputParams = new Map(this.inputs);
+      for (const input2 of node.inputs) {
+        if (input2.nodeId) {
+          const inputNode = this.getNodeById(input2.nodeId);
+          if (inputNode.subFlowList?.some(
+            (subItem) => subItem.startId === node.id
+          )) {
+            continue;
+          }
+          const result = await this.#runItem(inputNode, node, input2);
+          inputParams.set(input2.value, result);
+        }
+      }
+      const nodeRunner = await this.#createNodeRunner(
+        node,
+        inputParams,
+        callNode,
+        input
+      );
+      const outputList = node.outputs;
+      const outputName = input?.outputName ?? node.data.outputName ?? outputList[0].value;
+      let dataResult = this.#getCallCache(node.id);
+      if (dataResult === void 0) {
+        {
+          const res = await nodeRunner.run();
+          dataResult = { result: res };
+          this.#callCache.set(node.id, res);
+        }
+      }
+      const outputKey = `${node.id}|${outputName}`;
+      const outputResult = this.#getOuputCache(outputKey);
+      let returnData;
+      if (outputResult === void 0) {
+        const res = await dataResult.result(outputName);
+        this.#outputCache.set(outputKey, res);
+        returnData = res;
+      } else {
+        returnData = outputResult.result;
+      }
+      this.#emitter.send(
+        createResultData({
+          ...returnData,
+          node
+        })
+      );
+      return returnData;
+    } catch (error) {
+      if (error instanceof Error && error.message === "Request was aborted." || error instanceof AbortSignalError) {
+        return { value: void 0 };
+      }
+      const item = { title: node.data.title || "" };
+      if (error instanceof RunnerError) {
+        throw error.create(item);
+      } else {
+        if (error instanceof Error && error.message === "Connection error.") {
+          const newError = new RunnerError(error.cause, [
+            { ...item, message: "接口请求失败" }
+          ]);
+          delete newError.stack;
+          throw newError;
+        }
+        throw new RunnerError(error, [item]);
+      }
+    }
+  }
+};
+var WorkflowRunnerService = class {
+  #injector = inject8(Injector3);
+  /** 自己使用
+   * @internal
+   */
+  createContext(data, inputs, parent, parentInjector) {
+    return createInjector2({
+      providers: [
+        WorkflowRunnerContext,
+        { provide: CurrentWorkflowToken, useValue: data },
+        { provide: InputsToken, useValue: inputs },
+        { provide: ParentContextToken, useValue: parent }
+      ],
+      parent: parentInjector ?? this.#injector
+    }).get(WorkflowRunnerContext);
+  }
+  #log;
+  get log() {
+    return this.#log ?? (this.#log = this.#injector.get(LogService2, void 0, { optional: true })?.getToken("workflow"));
+  }
+  /** 入口 */
+  run(data, input, ob, signal2) {
+    this.log?.info("工作流默认对话配置", input.modelOptions);
+    const injector = createInjector2({
+      providers: [
+        WorkflowEmitter,
+        { provide: AbortSignalToken, useValue: signal2 },
+        {
+          provide: EnviromentParametersToken,
+          useValue: input.environmentParameters
+        },
+        { provide: ModelOptionsToken, useValue: input.modelOptions }
+      ],
+      parent: this.#injector
+    });
+    const runner = this.createContext(data, input.input, void 0, injector);
+    if (ob) {
+      injector.get(WorkflowEmitter).setObserver(ob);
+    }
+    return runner.startRun();
+  }
+};
+
+// packages/workflow/preset/inline-runner.service.ts
+var InlineParametersService = class {
+  #inlineBuild = inject9(InlineBuilderService);
+  #workflowRunner = inject9(WorkflowRunnerService);
+  async run(input) {
+    const define = this.#inlineBuild.createDefine({
+      ...input,
+      input: input.input ?? {},
+      context: input.context ?? {}
+    });
+    const result2 = await this.#workflowRunner.run(define.data, {
+      input: new Map(
+        Object.entries(input.input || {}).map(([key, value]) => [
+          key,
+          { value }
+        ])
+      ),
+      environmentParameters: input.environmentParameters,
+      modelOptions: input.modelOptions
+    });
+    return result2;
+  }
+};
+
+// packages/workflow/workflow-exec.service.ts
+import { Subject } from "rxjs";
+
+// packages/workflow/preset/context-build.service.ts
+import { inject as inject10 } from "static-injector";
+import { uniq } from "es-toolkit";
+var ContextBuildService = class {
+  template = inject10(TemplateFormatService);
+  parser = inject10(WorkflowParserService);
+  createWorkflow(input, inlineMode) {
+    const result = this.template.parse(
+      input.template.flatMap(
+        (item) => item.content.map((item2) => item2.type === "text" ? item2.text : "")
+      ).join("\n")
+    ).list.map((item) => item.value);
+    const inputList = [
+      uniq([
+        ...Object.keys({ ...input.input, ...input.context }),
+        ...result
+      ]).map((value, i) => ({
+        id: `${i}`,
+        value,
+        label: ``
+      }))
+    ];
+    const chatNode = {
+      id: "2",
+      data: {
+        title: "对话",
+        handle: {
+          input: inputList,
+          output: [
+            [
+              {
+                id: "1",
+                label: "",
+                value: "输出"
+              }
+            ]
+          ]
+        },
+        value: input.template,
+        config: {}
+      },
+      type: "chat"
+    };
+    if (!inlineMode) {
+      return {
+        nodes: [chatNode],
+        edges: []
+      };
+    }
+    const inputParamsNode = {
+      id: "1",
+      type: "input-params" /* inputParams */,
+      data: {
+        handle: {
+          input: [
+            [
+              {
+                ...generateHandle(DEFAULT_INPUT_KEY, ""),
+                inputType: "object"
+              }
+            ]
+          ],
+          output: [[{ id: "1", value: "default", label: "" }]]
+        }
+      }
+    };
+    const bridgeNodeList = inputList.flat().map((item, i) => ({
+      id: `${InlineInputItemRunner.runnerName}-${i}`,
+      type: InlineInputItemRunner.runnerName,
+      data: {
+        handle: {
+          input: [[{ id: "1", value: item.value, label: "" }]],
+          output: [
+            [
+              {
+                id: "1",
+                label: "",
+                value: "输出"
+              }
+            ]
+          ]
+        }
+      }
+    }));
+    const bridgeEdgeList1 = inputList.flat().map((item, i) => ({
+      source: inputParamsNode.id,
+      sourceHandle: "1",
+      target: `${InlineInputItemRunner.runnerName}-${i}`,
+      targetHandle: "1"
+    }));
+    const bridgeEdgeList2 = inputList.flat().map((item, i) => ({
+      source: `${InlineInputItemRunner.runnerName}-${i}`,
+      sourceHandle: "1",
+      target: chatNode.id,
+      targetHandle: item.id
+    }));
+    return {
+      nodes: [inputParamsNode, chatNode, ...bridgeNodeList],
+      edges: [...bridgeEdgeList1, ...bridgeEdgeList2]
+    };
+  }
+};
+
+// packages/workflow/workflow-exec.service.ts
+var WorkflowExecService = class {
+  #parser = inject11(WorkflowParserService);
+  #parameterResolve = inject11(InlineParametersService);
+  #runner = inject11(WorkflowRunnerService);
+  parse(data) {
+    return this.#parser.parse(data);
+  }
+  async runParse(define, input, ob, abortSignal) {
+    const parameters = await this.#parameterResolve.run(input);
+    return this.#runner.run(
+      define,
+      {
+        input: new Map(
+          Object.entries(parameters.value).map(([key, value]) => [key, value])
+        ),
+        environmentParameters: input.environmentParameters,
+        modelOptions: input.modelOptions
+      },
+      ob,
+      abortSignal
+    );
+  }
+  async exec(data, input, options, ob, abortSignal) {
+    let define;
+    if (data.define) {
+      define = data.define;
+    } else {
+      const res = this.#parser.parse(data);
+      if (res.error) {
+        throw res.error;
+      }
+      define = res.data;
+    }
+    try {
+      return await this.runParse(define, input, ob, abortSignal);
+    } catch (error) {
+      if (options.showError) {
+      }
+      throw error;
+    }
+  }
+  #contextBuild = inject11(ContextBuildService);
+  async agentChat(input, fn, abort) {
+    const workflow = this.#contextBuild.createWorkflow(input, input.inlineMode);
+    const subject = new Subject();
+    subject.subscribe({
+      next: (value) => {
+        fn(value);
+      }
+    });
+    const result2 = await this.exec(
+      { flow: workflow },
+      {
+        ...input
+      },
+      { showError: true },
+      subject,
+      abort
+    );
+    return result2;
+  }
+};
+
+// packages/workflow/workflow-select.service.ts
+import { computed as computed4, inject as inject13 } from "static-injector";
+import { createNormalizeVfs, path as path2 } from "@cyia/vfs2";
+
+// packages/workflow/workflow-file.service.ts
+import { inject as inject12 } from "static-injector";
+import { path } from "@cyia/vfs2";
+import { RawFile } from "@cyia/bundle-file";
+var WorkflowFileService = class {
+  #config = inject12(WorkflowConfigToken);
+  #fileMap = /* @__PURE__ */ new Map();
+  getFile(filePath) {
+    const nFilePath = path.normalize(filePath);
+    let file = this.#fileMap.get(nFilePath);
+    if (!file) {
+      file = new RawFile(nFilePath);
+      this.#fileMap.set(nFilePath, file);
+    }
+    return file;
+  }
+  /** 关闭已打开的默认工作流文件 */
+  async closeDefulatFile() {
+    const dir = path.join(this.#config().dir, "default");
+    for (const [filePath, file] of this.#fileMap) {
+      if (filePath.startsWith(dir)) {
+        await file.close();
+        this.#fileMap.delete(filePath);
+      }
+    }
+  }
+  async remove(filePath) {
+    const nFilePath = path.normalize(filePath);
+    const file = this.#fileMap.get(nFilePath);
+    if (!file) {
+      return;
+    }
+    await file.close();
+    this.#fileMap.delete(nFilePath);
+  }
+};
+
+// packages/workflow/workflow-select.service.ts
+var WorkflowSelectService = class {
+  #fileService = inject13(WorkflowFileService);
+  #config = inject13(WorkflowConfigToken);
+  #vfs = computed4(
+    () => createNormalizeVfs({
+      dir: this.#config().dir
+    })
+  );
+  async get({ workflowName }) {
+    const wfPath = path2.join(this.#config().dir, `${workflowName}.workflow`);
+    if (!await this.#vfs().exists(wfPath)) {
+      const isDefulat = workflowName.startsWith("default/");
+      throw new Error(
+        `工作流: [${workflowName}] 不存在;${isDefulat ? "您可以尝试[同步内置工作流]更新" : ""}`
+      );
+    }
+    const file = this.#fileService.getFile(wfPath);
+    return await file.readOriginData();
+  }
+  async getList() {
+    const rootDir = this.#config().dir;
+    const list = [];
+    const listG = this.#vfs().glob("**/*.workflow", { cwd: rootDir });
+    for await (const item of listG) {
+      const relFilePath = item.replace(/\.workflow$/, "");
+      list.push({
+        relPath: relFilePath,
+        name: path2.basename(relFilePath),
+        stat: await this.#vfs().stat(item)
+      });
+    }
+    return list;
+  }
+};
+
+// packages/workflow/module.ts
+var WORKFLOW_MODULE = {
+  provider: [
+    WorkflowExecService,
+    WorkflowParserService,
+    WorkflowSelectService,
+    WorkflowFileService,
+    ContextBuildService,
+    InlineBuilderService,
+    WorkflowRunnerService,
+    InlineParametersService,
+    WorkflowPluginService,
+    InlineNodeService
+  ],
+  token: {
+    ChatServiceToken,
+    WorkflowConfigToken
+  }
+};
+export {
+  AbortSignalToken,
+  ChatServiceToken,
+  CommonDataDefine,
+  CurrentCallNodeToken,
+  CurrentContextToken,
+  CurrentNodeToken,
+  CurrentWorkflowToken,
+  DEFAULT_CHAT_SCHEMA_KEY,
+  DEFAULT_INPUT_KEY,
+  EXAMPLES_DEFINE,
+  EnviromentParametersToken,
+  HandleDataDefine,
+  HelpObj,
+  INLINE_Template,
+  INLINE_Template2,
+  ITERATION_ITEM_SYMBOL,
+  InlineNodeService,
+  InputParamsToken,
+  InputsToken,
+  LLMDataDefine,
+  ModelOptionsToken,
+  NodeRunnerBase,
+  ParentContextToken,
+  RUNNER_ORIGIN_OUTPUT_KEY,
+  TemplateFormatService,
+  UseInputToken,
+  WORKFLOW_MODULE,
+  WorkflowConfigToken,
+  WorkflowEmitter,
+  WorkflowExecService,
+  WorkflowFileService,
+  WorkflowNodeType,
+  WorkflowParserService,
+  WorkflowPluginService,
+  WorkflowRunnerContext,
+  WorkflowRunnerService,
+  WorkflowSelectService,
+  createLLMData,
+  createResultData,
+  flatFilterHandleList,
+  generateHandle,
+  isChatStream,
+  llmModelConfig
+};
+//# sourceMappingURL=index.mjs.map