@ai-setting/roy-agent-core 1.6.11 → 1.6.13

package/dist/shared/@ai-setting/{roy-agent-core-06574wqa.js → roy-agent-core-v77pp20w.js}

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-0n2a8cbn.js";
+} from "./roy-agent-core-0crh2g0m.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -18,10 +18,10 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-mb7b62sm.js";
+} from "./roy-agent-core-8cbsjkkx.js";
 import {
   WorkflowService
-} from "./roy-agent-core-p2vpsd1d.js";
+} from "./roy-agent-core-ywtmc0bh.js";
 import {
   BaseComponent
 } from "./roy-agent-core-j62bjagf.js";
@@ -141,7 +141,7 @@ class WorkflowComponent extends BaseComponent {
     if (!agentRunner && this._workflowEnv) {
       const agentComponent = this._workflowEnv.getComponent("agent");
       if (agentComponent) {
-        const { AgentComponentAdapter } = await import("./roy-agent-core-z7f8hyv7.js");
+        const { AgentComponentAdapter } = await import("./roy-agent-core-6jqpdjr4.js");
         agentRunner = new AgentComponentAdapter(agentComponent, {}, this.sessionComponent);
       }
     }

package/dist/shared/@ai-setting/roy-agent-core-vcjq65nz.js

@@ -0,0 +1,436 @@
+import {
+  TracedAs,
+  init_decorator
+} from "./roy-agent-core-fdm579b1.js";
+import {
+  __esm,
+  __legacyDecorateClassTS
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/engine/dag-manager.ts
+var DAGManager;
+var init_dag_manager = __esm(() => {
+  init_decorator();
+  DAGManager = class DAGManager {
+    workflow;
+    nodeMap;
+    extendedDefinition = null;
+    cachedAnalysis = null;
+    allowCycles;
+    constructor(workflow, options) {
+      if (!workflow.nodes || workflow.nodes.length === 0) {
+        throw new Error("At least one node is required");
+      }
+      this.workflow = workflow;
+      this.nodeMap = new Map;
+      this.allowCycles = options?.allowCycles ?? false;
+      for (const node of workflow.nodes) {
+        if (node.id === "") {
+          throw new Error("Node ID cannot be empty");
+        }
+        if (this.nodeMap.has(node.id)) {
+          throw new Error(`Duplicate node ID: ${node.id}`);
+        }
+        this.nodeMap.set(node.id, node);
+      }
+    }
+    getExtendedDefinition() {
+      if (this.extendedDefinition) {
+        return this.extendedDefinition;
+      }
+      const analysis = this.analyze();
+      this.extendedDefinition = {
+        ...this.workflow,
+        computedEntry: analysis.entryNodes,
+        nodeMap: this.nodeMap,
+        topologicalOrder: this.getTopologicalOrder()
+      };
+      return this.extendedDefinition;
+    }
+    analyze() {
+      if (this.cachedAnalysis) {
+        return this.cachedAnalysis;
+      }
+      const dependencies = this.buildDependenciesMap();
+      const dependents = this.buildDependentsMap(dependencies);
+      const entryNodes = this.findEntryNodes(dependencies);
+      const exitNodes = this.findExitNodes(dependents);
+      const levels = this.computeLevels(dependencies);
+      const criticalPath = this.findCriticalPath(levels, dependencies);
+      this.cachedAnalysis = {
+        entryNodes,
+        exitNodes,
+        levels,
+        dependencies,
+        dependents,
+        criticalPath
+      };
+      return this.cachedAnalysis;
+    }
+    buildDependenciesMap() {
+      const dependencies = new Map;
+      for (const node of this.workflow.nodes) {
+        const deps = node.depends_on || [];
+        dependencies.set(node.id, [...deps]);
+      }
+      if (this.workflow.edges) {
+        for (const edge of this.workflow.edges) {
+          const targetDeps = dependencies.get(edge.to);
+          if (!targetDeps)
+            continue;
+          if (targetDeps.includes(edge.from))
+            continue;
+          if (!this.isReachable(edge.from, edge.to, dependencies)) {
+            targetDeps.push(edge.from);
+          }
+        }
+      }
+      return dependencies;
+    }
+    isReachable(source, target, dependencies) {
+      if (source === target)
+        return true;
+      const visited = new Set;
+      const queue = [source];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === target)
+          return true;
+        if (visited.has(current))
+          continue;
+        visited.add(current);
+        const deps = dependencies.get(current) || [];
+        for (const dep of deps) {
+          if (!visited.has(dep))
+            queue.push(dep);
+        }
+      }
+      return false;
+    }
+    buildDependentsMap(dependencies) {
+      const dependentsMap = new Map;
+      for (const nodeId of dependencies.keys()) {
+        dependentsMap.set(nodeId, []);
+      }
+      for (const [nodeId, deps] of dependencies.entries()) {
+        for (const dep of deps) {
+          const nodeDependents = dependentsMap.get(dep) || [];
+          nodeDependents.push(nodeId);
+          dependentsMap.set(dep, nodeDependents);
+        }
+      }
+      return dependentsMap;
+    }
+    findEntryNodes(dependencies) {
+      const entryNodes = [];
+      for (const [nodeId, deps] of dependencies.entries()) {
+        if (deps.length === 0) {
+          entryNodes.push(nodeId);
+        }
+      }
+      return entryNodes;
+    }
+    findExitNodes(dependents) {
+      const exitNodes = [];
+      for (const [nodeId, deps] of dependents.entries()) {
+        if (deps.length === 0) {
+          exitNodes.push(nodeId);
+        }
+      }
+      return exitNodes;
+    }
+    computeLevels(dependencies) {
+      const levels = [];
+      const assigned = new Set;
+      const nodeLevels = new Map;
+      const dependentsMap = this.buildDependentsMap(dependencies);
+      const entryNodes = this.findEntryNodes(dependencies);
+      const queue = [];
+      for (const entry of entryNodes) {
+        queue.push({ nodeId: entry, level: 0 });
+        nodeLevels.set(entry, 0);
+      }
+      while (queue.length > 0) {
+        const { nodeId, level } = queue.shift();
+        if (assigned.has(nodeId)) {
+          const currentLevel = nodeLevels.get(nodeId) || 0;
+          if (level > currentLevel) {
+            nodeLevels.set(nodeId, level);
+          }
+          continue;
+        }
+        assigned.add(nodeId);
+        nodeLevels.set(nodeId, level);
+        const dependentsOfNode = dependentsMap.get(nodeId) || [];
+        for (const dependent of dependentsOfNode) {
+          if (!assigned.has(dependent)) {
+            queue.push({ nodeId: dependent, level: level + 1 });
+          }
+        }
+      }
+      for (const nodeId of dependencies.keys()) {
+        if (!nodeLevels.has(nodeId)) {
+          nodeLevels.set(nodeId, 0);
+        }
+      }
+      const maxLevel = Math.max(...nodeLevels.values(), 0);
+      for (let i = 0;i <= maxLevel; i++) {
+        levels.push([]);
+      }
+      for (const [nodeId, level] of nodeLevels.entries()) {
+        levels[level].push(nodeId);
+      }
+      return levels;
+    }
+    findCriticalPath(levels, dependencies) {
+      if (levels.length === 0) {
+        return [];
+      }
+      const longestPath = new Map;
+      const allNodes = [];
+      for (const level of levels) {
+        allNodes.push(...level);
+      }
+      for (const nodeId of allNodes) {
+        const deps = dependencies.get(nodeId) || [];
+        if (deps.length === 0) {
+          longestPath.set(nodeId, { length: 1, path: [nodeId] });
+        } else {
+          let maxLength2 = 0;
+          let maxPath = [];
+          for (const dep of deps) {
+            const depInfo = longestPath.get(dep);
+            if (depInfo && depInfo.length > maxLength2) {
+              maxLength2 = depInfo.length;
+              maxPath = depInfo.path;
+            }
+          }
+          longestPath.set(nodeId, {
+            length: maxLength2 + 1,
+            path: [...maxPath, nodeId]
+          });
+        }
+      }
+      let maxLength = 0;
+      let criticalPath = [];
+      for (const [, info] of longestPath.entries()) {
+        if (info.length > maxLength) {
+          maxLength = info.length;
+          criticalPath = info.path;
+        }
+      }
+      return criticalPath;
+    }
+    getTopologicalOrder() {
+      const dependencies = this.buildDependenciesMap();
+      const dependents = this.buildDependentsMap(dependencies);
+      const inDegree = new Map;
+      for (const nodeId of dependencies.keys()) {
+        inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
+      }
+      const queue = [];
+      for (const [nodeId, degree] of inDegree.entries()) {
+        if (degree === 0) {
+          queue.push(nodeId);
+        }
+      }
+      const result = [];
+      while (queue.length > 0) {
+        const nodeId = queue.shift();
+        result.push(nodeId);
+        const nodeDependents = dependents.get(nodeId) || [];
+        for (const dependent of nodeDependents) {
+          const currentDegree = inDegree.get(dependent) || 0;
+          inDegree.set(dependent, currentDegree - 1);
+          if (currentDegree - 1 === 0) {
+            queue.push(dependent);
+          }
+        }
+      }
+      return result;
+    }
+    getReadyNodes(completedNodes) {
+      const dependencies = this.buildDependenciesMap();
+      const ready = [];
+      for (const nodeId of dependencies.keys()) {
+        if (completedNodes.has(nodeId)) {
+          continue;
+        }
+        if (this.areDependenciesMet(nodeId, completedNodes)) {
+          ready.push(nodeId);
+        }
+      }
+      return ready;
+    }
+    areDependenciesMet(nodeId, completedNodes) {
+      const analysis = this.analyze();
+      const deps = analysis.dependencies.get(nodeId);
+      if (!deps) {
+        return true;
+      }
+      for (const dep of deps) {
+        if (!completedNodes.has(dep)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    isCyclic() {
+      const dependencies = this.buildDependenciesMap();
+      const order = this.getTopologicalOrderInternal(dependencies);
+      return order.length !== this.workflow.nodes.length;
+    }
+    getTopologicalOrderInternal(dependencies) {
+      const dependents = this.buildDependentsMap(dependencies);
+      const inDegree = new Map;
+      for (const nodeId of dependencies.keys()) {
+        inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
+      }
+      const queue = [];
+      for (const [nodeId, degree] of inDegree.entries()) {
+        if (degree === 0) {
+          queue.push(nodeId);
+        }
+      }
+      const result = [];
+      while (queue.length > 0) {
+        const nodeId = queue.shift();
+        result.push(nodeId);
+        const nodeDependents = dependents.get(nodeId) || [];
+        for (const dependent of nodeDependents) {
+          const currentDegree = inDegree.get(dependent) || 0;
+          inDegree.set(dependent, currentDegree - 1);
+          if (currentDegree - 1 === 0) {
+            queue.push(dependent);
+          }
+        }
+      }
+      return result;
+    }
+    validate(options) {
+      const errors = [];
+      const nodeIds = new Set;
+      for (const node of this.workflow.nodes) {
+        if (node.id === "") {
+          errors.push("Node ID cannot be empty");
+          continue;
+        }
+        if (nodeIds.has(node.id)) {
+          errors.push(`Duplicate node ID: ${node.id}`);
+        }
+        nodeIds.add(node.id);
+      }
+      for (const node of this.workflow.nodes) {
+        const deps = node.depends_on || [];
+        for (const dep of deps) {
+          if (!nodeIds.has(dep)) {
+            errors.push(`Node '${node.id}' depends on non-existent node '${dep}'`);
+          }
+        }
+      }
+      if (!this.allowCycles && !options?.skipCycleCheck && this.isCyclic()) {
+        errors.push("Workflow contains a cycle");
+      }
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    }
+    addNode(node) {
+      if (!node.id || node.id.trim() === "") {
+        throw new Error("Node ID cannot be empty");
+      }
+      if (this.nodeMap.has(node.id)) {
+        throw new Error(`Node with ID '${node.id}' already exists`);
+      }
+      const deps = node.depends_on || [];
+      for (const dep of deps) {
+        if (!this.nodeMap.has(dep)) {
+          throw new Error(`Cannot add node '${node.id}': depends on non-existent node '${dep}'`);
+        }
+      }
+      const originalNodes = [...this.workflow.nodes];
+      this.workflow.nodes.push(node);
+      if (this.isCyclic()) {
+        this.workflow.nodes = originalNodes;
+        throw new Error(`Cannot add node '${node.id}': would create a cycle in the workflow`);
+      }
+      this.nodeMap.set(node.id, node);
+      this.cachedAnalysis = null;
+      this.extendedDefinition = null;
+    }
+    removeNode(nodeId) {
+      if (!this.nodeMap.has(nodeId)) {
+        throw new Error(`Node '${nodeId}' does not exist`);
+      }
+      const dependents = this.getDependents(nodeId);
+      if (dependents.length > 0) {
+        throw new Error(`Cannot remove node '${nodeId}': other nodes depend on it: ${dependents.join(", ")}`);
+      }
+      this.workflow.nodes = this.workflow.nodes.filter((n) => n.id !== nodeId);
+      this.nodeMap.delete(nodeId);
+      this.cachedAnalysis = null;
+      this.extendedDefinition = null;
+    }
+    getDependents(nodeId) {
+      const analysis = this.analyze();
+      return analysis.dependents.get(nodeId) || [];
+    }
+    getDownstreamUntil(fromNodeId, untilNodeId) {
+      const result = [];
+      const visited = new Set;
+      const queue = [...this.getDependents(fromNodeId)];
+      while (queue.length > 0) {
+        const nodeId = queue.shift();
+        if (visited.has(nodeId))
+          continue;
+        visited.add(nodeId);
+        result.push(nodeId);
+        if (nodeId === untilNodeId) {
+          continue;
+        }
+        for (const dependent of this.getDependents(nodeId)) {
+          if (!visited.has(dependent)) {
+            queue.push(dependent);
+          }
+        }
+      }
+      return result;
+    }
+    getDefinition() {
+      return this.workflow;
+    }
+    getNode(nodeId) {
+      return this.nodeMap.get(nodeId);
+    }
+    getNodeIds() {
+      return Array.from(this.nodeMap.keys());
+    }
+    getNodeCount() {
+      return this.nodeMap.size;
+    }
+    buildEdges(explicitEdges = []) {
+      const derivedEdges = [];
+      const explicitEdgeSet = new Set(explicitEdges.map((e) => `${e.from}->${e.to}`));
+      for (const node of this.workflow.nodes) {
+        const deps = node.depends_on || [];
+        for (const dep of deps) {
+          const edgeKey = `${dep}->${node.id}`;
+          if (!explicitEdgeSet.has(edgeKey)) {
+            derivedEdges.push({ from: dep, to: node.id });
+          }
+        }
+      }
+      return [...explicitEdges, ...derivedEdges];
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.dag-manager.areDependenciesMet", {
+      recordParams: true,
+      recordResult: true,
+      log: true
+    })
+  ], DAGManager.prototype, "areDependenciesMet", null);
+});
+
+export { DAGManager, init_dag_manager };

package/dist/shared/@ai-setting/{roy-agent-core-8wd3qwx5.js → roy-agent-core-wjve1qr5.js}

@@ -1,7 +1,7 @@
 import {
   DAGManager,
   init_dag_manager
-} from "./roy-agent-core-4yq23m5g.js";
+} from "./roy-agent-core-vcjq65nz.js";
 
 // src/env/workflow/utils/validate-workflow-definition.ts
 init_dag_manager();

package/dist/shared/@ai-setting/{roy-agent-core-5w9a1eqa.js → roy-agent-core-wpw37qqf.js}

@@ -1,16 +1,16 @@
 import {
   ProcessRegistry,
   runWithProcessRegistryAsync
-} from "./roy-agent-core-pzeexnhf.js";
+} from "./roy-agent-core-nv4yfy3m.js";
 import {
   builtInPrompts
-} from "./roy-agent-core-trdpar9f.js";
+} from "./roy-agent-core-apz6v22z.js";
 import {
   runWithBgTaskIdAsync
 } from "./roy-agent-core-c1v263jn.js";
 import {
   DEFAULT_SUBAGENT_PROMPT
-} from "./roy-agent-core-wqe84f84.js";
+} from "./roy-agent-core-v5nknfh0.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";
@@ -808,6 +808,77 @@ Use these as guidance to improve task execution efficiency.`;
   listTasks() {
     return Array.from(this.tasks.values());
   }
+  hasActiveTaskForParent(parentSessionId) {
+    if (!parentSessionId)
+      return false;
+    for (const task of this.tasks.values()) {
+      if (task.parentSessionId === parentSessionId && (task.status === "pending" || task.status === "running")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async stopAllForParent(parentSessionId) {
+    if (!parentSessionId) {
+      return { stoppedTaskIds: [] };
+    }
+    const stoppedTaskIds = [];
+    for (const [taskId, task] of this.tasks) {
+      if (task.parentSessionId === parentSessionId && (task.status === "running" || task.status === "pending")) {
+        try {
+          const res = await this.stopTask(taskId);
+          if (res?.success) {
+            stoppedTaskIds.push(taskId);
+          }
+        } catch (err) {
+          logger.warn(`[BackgroundTaskManager] stopAllForParent failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    return { stoppedTaskIds };
+  }
+  async forceStopAllAcrossParents() {
+    for (const [taskId, task] of this.tasks) {
+      try {
+        await this.processRegistries.get(taskId)?.killAll();
+      } catch (err) {
+        logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents killAll failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        await this.propagateStopToWorkflowRuns(taskId, "force stop all");
+      } catch (err) {
+        logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents propagateStopToWorkflowRuns failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      let justMarkedStopped = false;
+      if (task.status === "running" || task.status === "pending") {
+        try {
+          task.status = "stopped";
+          task.completedAt = Date.now();
+          task.lastUpdatedAt = task.completedAt;
+          task.abortController?.abort();
+          justMarkedStopped = true;
+        } catch (err) {
+          logger.warn(`[BackgroundTaskManager] forceStopAllAcrossParents mark stopped failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (justMarkedStopped) {
+        const stoppedPayload = {
+          backgroundTaskId: task.id,
+          subSessionId: task.subSessionId,
+          parentSessionId: task.parentSessionId,
+          status: "stopped",
+          description: task.description,
+          error: "force stop all",
+          executionTimeMs: task.startedAt && task.completedAt ? task.completedAt - task.startedAt : 0,
+          associatedTaskId: task.associatedTaskId
+        };
+        this.publishBackgroundEvent(BackgroundTaskEventTypes.STOPPED, stoppedPayload, task.parentSessionId);
+      }
+    }
+  }
+  async forceStopAll() {
+    return this.forceStopAllAcrossParents();
+  }
   async dispose() {
     for (const [taskId, controller] of this.abortControllers) {
       controller.abort();
@@ -878,6 +949,20 @@ __legacyDecorateClassTS([
 __legacyDecorateClassTS([
   TracedAs("delegate.executeWithAbort", { recordParams: true, recordResult: true, log: true })
 ], BackgroundTaskManager.prototype, "executeWithAbort", null);
+__legacyDecorateClassTS([
+  TracedAs("task.background.stopAllForParent", {
+    recordParams: true,
+    recordResult: true,
+    log: true
+  })
+], BackgroundTaskManager.prototype, "stopAllForParent", null);
+__legacyDecorateClassTS([
+  TracedAs("task.background.forceStopAllAcrossParents", {
+    recordParams: false,
+    recordResult: true,
+    log: true
+  })
+], BackgroundTaskManager.prototype, "forceStopAllAcrossParents", null);
 function getAgentRegistry(taskComponent) {
   const agentComponent = taskComponent.env?.getComponent?.("agent");
   return agentComponent?.getRegistry?.();

package/dist/shared/@ai-setting/{roy-agent-core-p6x6n3k4.js → roy-agent-core-x7fgze6s.js}

@@ -7,7 +7,7 @@ import {
 import {
   getCurrentProcessRegistry,
   killProcessTree
-} from "./roy-agent-core-pzeexnhf.js";
+} from "./roy-agent-core-nv4yfy3m.js";
 import {
   init_decorator,
   wrapFunction