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

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

@@ -2,12 +2,18 @@ import {
   TracedAs,
   init_decorator
 } from "./roy-agent-core-fdm579b1.js";
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-vyygk314.js";
 import {
   __legacyDecorateClassTS
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/service/workflow-service.ts
+init_logger();
 init_decorator();
+var logger = createLogger("WorkflowService");
 var TAG_MIN_COUNT = 1;
 var TAG_MAX_COUNT = 3;
 class TagValidationError extends Error {
@@ -27,7 +33,27 @@ class WorkflowService {
     this.engineFactory = engineFactory;
     this.sessionComponent = sessionComponent;
     this.tagRepository = tagRepository;
+    this.engineInstances = new Map;
+  }
+  async listAllSessions() {
+    if (!this.sessionComponent?.list)
+      return [];
+    const PAGE = 1000;
+    const HARD_CAP = 50000;
+    const collected = [];
+    let offset = 0;
+    while (collected.length < HARD_CAP) {
+      const batch = await this.sessionComponent.list({ limit: PAGE, offset });
+      collected.push(...batch);
+      if (batch.length < PAGE)
+        break;
+      offset += PAGE;
+    }
+    return collected;
   }
+  engineInstances;
+  sessionToEngine = new Map;
+  sessionToParent = new Map;
   validateTags(tags) {
     const effective = tags ?? [];
     if (effective.length < TAG_MIN_COUNT) {
@@ -233,14 +259,24 @@ class WorkflowService {
         };
       }
     }
-    const engine = this.engineFactory(workflow, {
-      ...options,
-      input
-    });
+    let engine = this.engineInstances.get(workflow.name);
+    if (!engine) {
+      engine = this.engineFactory(workflow, {
+        ...options,
+        input
+      });
+      this.engineInstances.set(workflow.name, engine);
+    }
     const result = await engine.runWorkflow(workflow, {
       ...options,
       input
     });
+    const resolvedSessionId = result.sessionId || result.runId;
+    if (resolvedSessionId) {
+      this.sessionToEngine.set(resolvedSessionId, engine);
+      const parentSid = options?.parentSessionId;
+      this.sessionToParent.set(resolvedSessionId, typeof parentSid === "string" ? parentSid : undefined);
+    }
     return {
       ...result,
       runId: result.runId || result.sessionId || "",
@@ -267,8 +303,111 @@ class WorkflowService {
     if (!workflow) {
       throw new Error(`Workflow not found: ${metadata.workflowName}`);
     }
-    const engine = this.engineFactory(workflow);
-    await engine.stop(sessionId, reason);
+    const cachedBySession = this.sessionToEngine.get(sessionId);
+    const cachedByName = this.engineInstances.get(metadata.workflowName);
+    const engine = cachedBySession ?? cachedByName ?? this.engineFactory(workflow);
+    try {
+      await engine.stop(sessionId, reason);
+    } finally {
+      this.sessionToEngine.delete(sessionId);
+      this.sessionToParent.delete(sessionId);
+      this.pruneStaleEngines();
+    }
+  }
+  pruneStaleEngines() {
+    for (const [workflowName, engine] of this.engineInstances) {
+      if (!engine?.activeSessions || engine.activeSessions.size === 0) {
+        this.engineInstances.delete(workflowName);
+      }
+    }
+  }
+  async dispose() {
+    for (const [, engine] of this.engineInstances) {
+      if (engine?.activeSessions) {
+        for (const sessionId of engine.activeSessions.keys()) {
+          try {
+            await engine.stop(sessionId, "WorkflowService disposed");
+          } catch {}
+        }
+      }
+    }
+    this.engineInstances.clear();
+    this.sessionToEngine.clear();
+  }
+  hasActiveWorkflowForParent(parentSessionId) {
+    if (!parentSessionId)
+      return false;
+    for (const [sessionId, recordedParent] of this.sessionToParent) {
+      if (recordedParent === undefined)
+        continue;
+      if (recordedParent === parentSessionId) {
+        const engine = this.sessionToEngine.get(sessionId);
+        const active = engine?.activeSessions;
+        if (active && active.has(sessionId))
+          return true;
+      }
+    }
+    return false;
+  }
+  async stopAllForParent(parentSessionId) {
+    if (!parentSessionId || !this.sessionComponent?.list) {
+      return { stoppedSessionIds: [], errors: [] };
+    }
+    const allSessions = await this.listAllSessions();
+    const stoppedSessionIds = [];
+    const errors = [];
+    for (const session of allSessions) {
+      const meta = session.metadata;
+      if (session.parentSessionId === parentSessionId && meta?.type === "workflow" && (meta?.status === "running" || meta?.status === "paused")) {
+        try {
+          await this.stopRun(session.id, "ESC cascade stop");
+          stoppedSessionIds.push(session.id);
+        } catch (err) {
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          const stack = err instanceof Error ? err.stack : undefined;
+          logger.warn(`[WorkflowService] stopAllForParent failed for ${session.id}: ${errorMsg}`);
+          errors.push({ sessionId: session.id, error: errorMsg, stack });
+        }
+      }
+    }
+    return { stoppedSessionIds, errors };
+  }
+  async forceStopAll() {
+    if (!this.sessionComponent?.list || !this.sessionComponent.update) {
+      return;
+    }
+    const allSessions = await this.listAllSessions();
+    const evictedSessionIds = [];
+    for (const session of allSessions) {
+      const meta = session.metadata;
+      if (meta?.type === "workflow" && (meta?.status === "running" || meta?.status === "paused")) {
+        const cachedEngine = this.sessionToEngine.get(session.id);
+        if (cachedEngine && typeof cachedEngine.stop === "function") {
+          try {
+            await cachedEngine.stop(session.id, "force stop all");
+          } catch (err) {
+            logger.warn(`[WorkflowService] forceStopAll engine.stop failed for ${session.id}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        try {
+          await this.sessionComponent.update(session.id, {
+            metadata: { ...meta, status: "stopped" }
+          });
+          evictedSessionIds.push(session.id);
+        } catch (err) {
+          logger.warn(`[WorkflowService] forceStopAll update failed for ${session.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    for (const sid of evictedSessionIds) {
+      const engine = this.sessionToEngine.get(sid);
+      if (engine?.activeSessions) {
+        engine.activeSessions.delete(sid);
+      }
+      this.sessionToEngine.delete(sid);
+      this.sessionToParent.delete(sid);
+    }
+    this.pruneStaleEngines();
   }
   async resumeSession(sessionId, options) {
     if (!this.sessionComponent) {
@@ -364,6 +503,27 @@ __legacyDecorateClassTS([
     log: false
   })
 ], WorkflowService.prototype, "getTag", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.hasActiveWorkflowForParent", {
+    recordParams: true,
+    recordResult: true,
+    log: false
+  })
+], WorkflowService.prototype, "hasActiveWorkflowForParent", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.stopAllForParent", {
+    recordParams: true,
+    recordResult: true,
+    log: true
+  })
+], WorkflowService.prototype, "stopAllForParent", null);
+__legacyDecorateClassTS([
+  TracedAs("workflow.service.forceStopAll", {
+    recordParams: false,
+    recordResult: true,
+    log: true
+  })
+], WorkflowService.prototype, "forceStopAll", null);
 __legacyDecorateClassTS([
   TracedAs("workflow.service.resumeSession", {
     recordParams: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.6.12",
+  "version": "1.6.13",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",

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

@@ -1,421 +0,0 @@
-import {
-  __esm
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/workflow/engine/dag-manager.ts
-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];
-  }
-}
-var init_dag_manager = () => {};
-
-export { DAGManager, init_dag_manager };