@ai-setting/roy-agent-core 1.4.13 → 1.4.14

package/dist/packages/core/src/env/workflow/utils/index.js

@@ -0,0 +1,637 @@
+import {
+  TracedAs,
+  init_decorator
+} from "../../../../../../shared/@ai-setting/roy-agent-core-04qgbjbe.js";
+import"../../../../../../shared/@ai-setting/roy-agent-core-yn761yve.js";
+import"../../../../../../shared/@ai-setting/roy-agent-core-1k28kg7h.js";
+import"../../../../../../shared/@ai-setting/roy-agent-core-j8zx62zr.js";
+import {
+  __legacyDecorateClassTS
+} from "../../../../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
+
+// packages/core/src/env/workflow/utils/template-resolver.ts
+class TemplateResolver {
+  input;
+  previousOutputs;
+  constructor(options = {}) {
+    this.input = options.input ?? {};
+    this.previousOutputs = options.previousOutputs ?? new Map;
+  }
+  static fromContext(context) {
+    return new TemplateResolver({
+      input: context.input,
+      previousOutputs: context.previousOutputs
+    });
+  }
+  resolveValue(input) {
+    if (input === null || input === undefined) {
+      return input;
+    }
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate);
+      }
+      return this.resolveString(input);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveValue(item));
+    }
+    if (typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveValue(value);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent) {
+    const value = this.resolveTemplateContent(templateContent);
+    return value;
+  }
+  resolveTemplateContent(templateContent) {
+    const trimmed = templateContent.trim();
+    if (trimmed.startsWith("input.")) {
+      return this.getNestedValue(this.input, trimmed.slice(6));
+    }
+    if (trimmed.startsWith("nodes.")) {
+      return this.resolveNodePath(trimmed.slice(6));
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      return this.resolveNodePath(`${nodeId}${restPath ? "." + restPath : ""}`);
+    }
+    return;
+  }
+  resolveString(template) {
+    if (!template || typeof template !== "string") {
+      return template;
+    }
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(this.input, path);
+      return this.stringify(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.resolveNodePath(path);
+      return this.stringify(value, match);
+    });
+    resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_-]*)(?:\.([^}]+))?\}\}/g, (match, nodeId, path) => {
+      if (nodeId === "input") {
+        return match;
+      }
+      if (nodeId === "nodes") {
+        return match;
+      }
+      const value = this.resolveNodePath(`${nodeId}${path ? "." + path : ""}`);
+      return this.stringify(value, match);
+    });
+    return resolved;
+  }
+  resolveNodePath(path) {
+    const segments = path.split(".");
+    const nodeId = segments[0];
+    if (!nodeId) {
+      return;
+    }
+    let value = this.previousOutputs.get(nodeId);
+    if (value === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        value = this.previousOutputs.get(normalizedUnderscore);
+      }
+      if (value === undefined && normalizedHyphen !== nodeId) {
+        value = this.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (value === undefined) {
+      return;
+    }
+    if (segments.length === 1) {
+      if (value && typeof value === "object" && "result" in value && !("nodes" in value)) {
+        value = value.result;
+      }
+      return value;
+    }
+    const secondSegment = segments[1];
+    if (secondSegment === "result" || secondSegment === "output") {
+      if (value && typeof value === "object" && "result" in value) {
+        value = value.result;
+        if (segments.length === 2) {
+          return value;
+        }
+        for (let i = 2;i < segments.length; i++) {
+          if (value === null || value === undefined) {
+            return;
+          }
+          value = value[segments[i]];
+        }
+        return value;
+      }
+    }
+    for (let i = 1;i < segments.length; i++) {
+      if (value === null || value === undefined) {
+        return;
+      }
+      value = value[segments[i]];
+    }
+    return value;
+  }
+  getNestedValue(obj, path) {
+    if (!obj || !path) {
+      return;
+    }
+    const segments = path.split(".");
+    let current = obj;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      if (typeof current !== "object") {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  stringify(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value === null) {
+      return "null";
+    }
+    return JSON.stringify(value);
+  }
+  containsTemplates(str) {
+    if (typeof str !== "string") {
+      return false;
+    }
+    return /\{\{[^}]+\}\}/.test(str);
+  }
+  extractTemplates(str) {
+    if (typeof str !== "string") {
+      return [];
+    }
+    const matches = str.match(/\{\{[^}]+\}\}/g);
+    return matches ?? [];
+  }
+}
+function resolveTemplates(input, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveValue(input);
+}
+function resolveTemplateString(template, context) {
+  const resolver = TemplateResolver.fromContext(context);
+  return resolver.resolveString(template);
+}
+// packages/core/src/env/workflow/utils/recovery-validator.ts
+init_decorator();
+
+// packages/core/src/env/workflow/utils/validation-rules.ts
+var ValidationErrorType;
+((ValidationErrorType2) => {
+  ValidationErrorType2["MISSING_VARIABLE"] = "MISSING_VARIABLE";
+  ValidationErrorType2["INCOMPLETE_PARALLEL"] = "INCOMPLETE_PARALLEL";
+  ValidationErrorType2["AMBIGUOUS_BRANCH"] = "AMBIGUOUS_BRANCH";
+  ValidationErrorType2["LOOP_STATE_LOST"] = "LOOP_STATE_LOST";
+  ValidationErrorType2["NESTED_WORKFLOW_INVALID"] = "NESTED_WORKFLOW_INVALID";
+  ValidationErrorType2["NODE_STATE_INCONSISTENT"] = "NODE_STATE_INCONSISTENT";
+  ValidationErrorType2["MISSING_DEPENDENCY"] = "MISSING_DEPENDENCY";
+})(ValidationErrorType ||= {});
+var SuggestedAction;
+((SuggestedAction2) => {
+  SuggestedAction2["RE_RUN"] = "RE_RUN";
+  SuggestedAction2["CONFIRM"] = "CONFIRM";
+  SuggestedAction2["SKIP"] = "SKIP";
+  SuggestedAction2["PROVIDE_VALUE"] = "PROVIDE_VALUE";
+  SuggestedAction2["IGNORE"] = "IGNORE";
+})(SuggestedAction ||= {});
+
+// packages/core/src/env/workflow/utils/execution-state.ts
+init_decorator();
+class ExecutionStateBuilder {
+  build(messages, definition) {
+    const state = {
+      completedNodes: new Set,
+      inProgressNodes: new Set,
+      pendingNodes: new Set,
+      nodeOutputs: new Map,
+      nodeInputs: new Map,
+      variables: new Map,
+      loopCounts: new Map
+    };
+    this.parseMessages(messages, state);
+    this.buildPendingNodes(definition, state);
+    return state;
+  }
+  parseMessages(messages, state) {
+    let lastCallNodeId = null;
+    let lastCallInput = null;
+    for (const msg of messages) {
+      const metadata = msg.metadata;
+      const msgType = metadata?.type;
+      switch (msgType) {
+        case "workflow.node.call": {
+          const nodeId = metadata?.workflowNodeId;
+          if (nodeId) {
+            lastCallNodeId = nodeId;
+            lastCallInput = this.extractInput(msg);
+            state.inProgressNodes.add(nodeId);
+            state.nodeInputs.set(nodeId, lastCallInput);
+          }
+          break;
+        }
+        case "workflow.node.result": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.delete(lastCallNodeId);
+            state.completedNodes.add(lastCallNodeId);
+            const output = this.extractOutput(msg);
+            state.nodeOutputs.set(lastCallNodeId, output);
+            this.extractVariables(output, state);
+            lastCallNodeId = null;
+            lastCallInput = null;
+          }
+          break;
+        }
+        case "workflow.node.interrupt": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.add(lastCallNodeId);
+          }
+          break;
+        }
+        case "workflow.node.resume": {
+          if (lastCallNodeId) {
+            state.inProgressNodes.add(lastCallNodeId);
+          }
+          break;
+        }
+      }
+    }
+  }
+  buildPendingNodes(definition, state) {
+    const nodeIds = new Set((definition.nodes || []).map((n) => n.id));
+    const allNodeIds = Array.from(nodeIds);
+    const entryNodes = this.getEntryNodes(definition);
+    for (const entryNode of entryNodes) {
+      if (!state.completedNodes.has(entryNode)) {
+        this.markPendingFromNode(entryNode, definition, state);
+      }
+    }
+    for (const completedId of state.completedNodes) {
+      const children = this.getDirectChildren(completedId, definition);
+      for (const childId of children) {
+        if (!state.completedNodes.has(childId) && !state.inProgressNodes.has(childId)) {
+          state.pendingNodes.add(childId);
+        }
+      }
+    }
+  }
+  getEntryNodes(definition) {
+    const entry = definition.entry;
+    if (!entry) {
+      return [];
+    }
+    if (Array.isArray(entry)) {
+      return entry;
+    }
+    return [entry];
+  }
+  markPendingFromNode(startNodeId, definition, state) {
+    const visited = new Set;
+    const queue = [startNodeId];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      if (visited.has(nodeId)) {
+        continue;
+      }
+      visited.add(nodeId);
+      if (!state.completedNodes.has(nodeId)) {
+        state.pendingNodes.add(nodeId);
+      }
+      const children = this.getDirectChildren(nodeId, definition);
+      for (const childId of children) {
+        if (!visited.has(childId)) {
+          queue.push(childId);
+        }
+      }
+    }
+  }
+  getDirectChildren(nodeId, definition) {
+    const edges = definition.edges || definition.connections || [];
+    return edges.filter((edge) => edge.source === nodeId || edge.from === nodeId).map((edge) => edge.target || edge.to);
+  }
+  extractInput(msg) {
+    try {
+      return JSON.parse(msg.content);
+    } catch {
+      return msg.content;
+    }
+  }
+  extractOutput(msg) {
+    try {
+      return JSON.parse(msg.content);
+    } catch {
+      return msg.content;
+    }
+  }
+  extractVariables(output, state) {
+    if (!output || typeof output !== "object") {
+      return;
+    }
+    const outputObj = output;
+    for (const [key, value] of Object.entries(outputObj)) {
+      if (key.startsWith("_") || key.startsWith("$")) {
+        continue;
+      }
+      if (!state.variables.has(key)) {
+        state.variables.set(key, value);
+      }
+    }
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.build", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "build", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.parseMessages", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "parseMessages", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.builder.buildPendingNodes", { recordParams: true, recordResult: true, log: true })
+], ExecutionStateBuilder.prototype, "buildPendingNodes", null);
+
+// packages/core/src/env/workflow/utils/recovery-validator.ts
+class RecoveryValidator {
+  stateBuilder;
+  constructor() {
+    this.stateBuilder = new ExecutionStateBuilder;
+  }
+  async validate(messages, definition) {
+    const state = this.stateBuilder.build(messages, definition);
+    const errors = [];
+    const warnings = [];
+    errors.push(...this.validateStateIntegrity(state, definition));
+    errors.push(...this.validateParallelBranches(state, definition));
+    errors.push(...this.validateConditionBranches(state, definition));
+    errors.push(...this.validateLoopState(state, definition));
+    errors.push(...this.validateNestedWorkflows(state, definition));
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  async generatePlan(messages, definition) {
+    const state = this.stateBuilder.build(messages, definition);
+    const validationResult = await this.validate(messages, definition);
+    const pendingNodes = Array.from(state.pendingNodes);
+    const completedNodes = Array.from(state.completedNodes);
+    const resumePoint = this.determineResumePoint(state, definition);
+    const summary = this.generateSummary(state, validationResult);
+    return {
+      canResume: validationResult.isValid,
+      resumePoint,
+      completedNodes,
+      pendingNodes,
+      skippedNodes: [],
+      validationErrors: validationResult.errors,
+      summary
+    };
+  }
+  validateStateIntegrity(state, definition) {
+    const errors = [];
+    for (const nodeId of state.pendingNodes) {
+      const node = definition.nodes?.find((n) => n.id === nodeId);
+      if (!node?.config)
+        continue;
+      const variableRefs = this.extractVariableRefs(node.config);
+      for (const varRef of variableRefs) {
+        if (!state.nodeOutputs.has(varRef) && !state.variables.has(varRef)) {
+          errors.push({
+            type: "MISSING_VARIABLE" /* MISSING_VARIABLE */,
+            nodeId,
+            description: `变量 ${varRef} 不存在，需要重新运行`,
+            suggestedAction: "RE_RUN" /* RE_RUN */,
+            context: { variable: varRef, nodeConfig: node.config }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateParallelBranches(state, definition) {
+    const errors = [];
+    const parallelGroups = this.identifyParallelGroups(definition);
+    for (const group of parallelGroups) {
+      const completedInGroup = group.filter((id) => state.completedNodes.has(id));
+      const inProgressInGroup = group.filter((id) => state.inProgressNodes.has(id));
+      if (inProgressInGroup.length > 0 || completedInGroup.length < group.length) {
+        const mergeNode = this.findMergeNodeForParallel(group, definition);
+        if (mergeNode && !state.completedNodes.has(mergeNode)) {
+          const incomplete = group.filter((id) => !state.completedNodes.has(id));
+          errors.push({
+            type: "INCOMPLETE_PARALLEL" /* INCOMPLETE_PARALLEL */,
+            nodeId: mergeNode,
+            description: `并行分支 ${incomplete.join(", ")} 未完成`,
+            suggestedAction: "RE_RUN" /* RE_RUN */,
+            context: { incompleteBranches: incomplete, mergeNode }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateConditionBranches(state, definition) {
+    const errors = [];
+    const edges = definition.edges || definition.connections || [];
+    const conditionalEdges = edges.filter((e) => e.condition);
+    for (const edge of conditionalEdges) {
+      const conditionVars = this.extractVariableRefs(edge.condition);
+      for (const varRef of conditionVars) {
+        if (!state.nodeOutputs.has(varRef) && !state.variables.has(varRef)) {
+          errors.push({
+            type: "AMBIGUOUS_BRANCH" /* AMBIGUOUS_BRANCH */,
+            nodeId: edge.target || edge.to,
+            description: `条件分支无法确定：变量 ${varRef} 不存在`,
+            suggestedAction: "CONFIRM" /* CONFIRM */,
+            context: { variable: varRef, condition: edge.condition }
+          });
+        }
+      }
+    }
+    return errors;
+  }
+  validateLoopState(state, definition) {
+    const errors = [];
+    const loops = this.identifyLoops(definition);
+    for (const loop of loops) {
+      const loopCounter = `loop_count_${loop.header}`;
+      if (!state.nodeOutputs.has(loopCounter) && state.pendingNodes.has(loop.header)) {
+        errors.push({
+          type: "LOOP_STATE_LOST" /* LOOP_STATE_LOST */,
+          nodeId: loop.header,
+          description: `循环状态丢失，循环计数器 ${loopCounter} 不存在`,
+          suggestedAction: "RE_RUN" /* RE_RUN */,
+          context: { loopHeader: loop.header }
+        });
+      }
+    }
+    return errors;
+  }
+  validateNestedWorkflows(state, definition) {
+    const errors = [];
+    const workflowNodes = (definition.nodes || []).filter((n) => n.type === "workflow");
+    for (const node of workflowNodes) {
+      const nodeOutput = state.nodeOutputs.get(node.id);
+      const subSessionId = nodeOutput?.sessionId;
+      if (subSessionId && state.pendingNodes.has(node.id)) {}
+    }
+    return errors;
+  }
+  extractVariableRefs(obj) {
+    const refs = [];
+    if (!obj)
+      return refs;
+    const str = JSON.stringify(obj);
+    const regex = /\{\{([^}]+)\}\}/g;
+    let match;
+    while ((match = regex.exec(str)) !== null) {
+      refs.push(match[1].trim());
+    }
+    return refs;
+  }
+  identifyParallelGroups(definition) {
+    const groups = [];
+    const sources = new Map;
+    const edges = definition.edges || definition.connections || [];
+    for (const edge of edges) {
+      const source = edge.source || edge.from;
+      const target = edge.target || edge.to;
+      const targets = sources.get(source) || [];
+      targets.push(target);
+      sources.set(source, targets);
+    }
+    for (const [_source, targets] of sources) {
+      if (targets.length > 1) {
+        groups.push(targets);
+      }
+    }
+    return groups;
+  }
+  findMergeNodeForParallel(parallelIds, definition) {
+    const edges = definition.edges || definition.connections || [];
+    for (const edge of edges) {
+      const target = edge.target || edge.to;
+      const source = edge.source || edge.from;
+      const allSourcesFromParallel = parallelIds.includes(source);
+      const hasIncomingFromParallel = parallelIds.some((id) => edges.some((e) => (e.source || e.from) === id && (e.target || e.to) === target));
+      if (allSourcesFromParallel && hasIncomingFromParallel) {
+        return target;
+      }
+    }
+    return null;
+  }
+  identifyLoops(definition) {
+    const loops = [];
+    const visited = new Set;
+    const recStack = new Set;
+    const edges = definition.edges || definition.connections || [];
+    const getChildren = (nodeId) => {
+      return edges.filter((e) => (e.source || e.from) === nodeId).map((e) => e.target || e.to);
+    };
+    const dfs = (nodeId, path) => {
+      visited.add(nodeId);
+      recStack.add(nodeId);
+      const outgoing = getChildren(nodeId);
+      for (const childId of outgoing) {
+        if (!visited.has(childId)) {
+          dfs(childId, [...path, childId]);
+        } else if (recStack.has(childId)) {
+          const loopStart = path.indexOf(childId);
+          if (loopStart !== -1) {
+            loops.push({
+              header: childId,
+              body: path.slice(loopStart)
+            });
+          }
+        }
+      }
+      recStack.delete(nodeId);
+    };
+    for (const node of definition.nodes || []) {
+      if (!visited.has(node.id)) {
+        dfs(node.id, [node.id]);
+      }
+    }
+    return loops;
+  }
+  determineResumePoint(state, definition) {
+    const inProgress = Array.from(state.inProgressNodes);
+    if (inProgress.length > 0) {
+      return inProgress[0];
+    }
+    const pending = Array.from(state.pendingNodes);
+    if (pending.length > 0) {
+      return pending[0];
+    }
+    const entry = definition.entry;
+    if (Array.isArray(entry)) {
+      return entry[0] || "";
+    }
+    return entry || "";
+  }
+  generateSummary(state, result) {
+    if (result.isValid) {
+      return `恢复验证通过。已完成 ${state.completedNodes.size} 个节点，待执行 ${state.pendingNodes.size} 个节点。`;
+    }
+    const errorTypes = result.errors.map((e) => e.type).join(", ");
+    return `恢复验证失败：${errorTypes}。${result.errors.length} 个错误需要处理。`;
+  }
+}
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validate", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validate", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.generate.plan", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "generatePlan", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateStateIntegrity", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateStateIntegrity", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateParallel", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateParallelBranches", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateCondition", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateConditionBranches", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateLoop", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateLoopState", null);
+__legacyDecorateClassTS([
+  TracedAs("recovery.validator.validateNested", { recordParams: true, recordResult: true, log: true })
+], RecoveryValidator.prototype, "validateNestedWorkflows", null);
+export {
+  resolveTemplates,
+  resolveTemplateString,
+  ValidationErrorType,
+  TemplateResolver,
+  SuggestedAction,
+  RecoveryValidator,
+  ExecutionStateBuilder
+};