@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

package/dist/env/workflow/utils/index.js

@@ -1,637 +0,0 @@
-import {
-  TracedAs,
-  init_decorator
-} from "../../../shared/@ai-setting/roy-agent-core-zgypchmt.js";
-import"../../../shared/@ai-setting/roy-agent-core-44hnfb02.js";
-import"../../../shared/@ai-setting/roy-agent-core-xs5rsgat.js";
-import"../../../shared/@ai-setting/roy-agent-core-psv4v63c.js";
-import {
-  __legacyDecorateClassTS
-} from "../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";
-
-// 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);
-}
-// src/env/workflow/utils/recovery-validator.ts
-init_decorator();
-
-// 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 ||= {});
-
-// 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);
-
-// 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
-};