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

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

@@ -173,12 +173,13 @@ class ProcessRegistry {
       try {
         const result = await killProcessTree(pid, { retry: 3, retryDelayMs: 500 });
         if (result.stillAlive) {
-          logger2.error(`进程 PID ${pid} 经过 ${result.attempts} 次重试后仍未杀死！可能存在孤儿进程泄漏！`);
+          logger2.error(`进程 PID ${pid} 经过 ${result.attempts} 次重试后仍未杀死！保留 PID 供后续 forceStopAll 重试。`);
+        } else {
+          this.pids.delete(pid);
         }
       } catch {}
     }
-    this.pids.clear();
-    logger2.info(`[bg-process:killAll-done]`);
+    logger2.info(`[bg-process:killAll-done] remaining=${this.pids.size}`);
   }
 }
 var processRegistryStorage = new AsyncLocalStorage;

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

@@ -7,7 +7,7 @@ import {
   nodeNotFound,
   pathNotFound,
   unresolvedVariable
-} from "./roy-agent-core-qnrf2aw6.js";
+} from "./roy-agent-core-jrj30vq3.js";
 import {
   TracedAs,
   init_decorator
@@ -81,25 +81,104 @@ var init_template_resolver = __esm(() => {
       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));
+    resolvePath(path) {
+      if (typeof path !== "string")
+        return;
+      const trimmed = path.trim();
+      if (trimmed === "")
+        return;
+      let inner = trimmed;
+      if (inner.startsWith("{{") && inner.endsWith("}}")) {
+        inner = inner.slice(2, -2).trim();
       }
-      if (trimmed.startsWith("inputs.")) {
-        return this.getNestedValue(this.input, trimmed.slice(7));
+      if (inner === "")
+        return;
+      return this.resolveTemplateContent(inner);
+    }
+    tokenizePath(path) {
+      const tokens = [];
+      const re = /([^.\[\]]+)|\[(-?\d+)\]/g;
+      let m;
+      while ((m = re.exec(path)) !== null) {
+        if (m[1] !== undefined) {
+          tokens.push(m[1]);
+        } else if (m[2] !== undefined) {
+          tokens.push(parseInt(m[2], 10));
+        }
       }
-      if (trimmed.startsWith("nodes.")) {
-        return this.resolveNodePath(trimmed.slice(6));
+      return tokens;
+    }
+    navigateTokens(root, tokens) {
+      let current = root;
+      for (const token of tokens) {
+        if (current === null || current === undefined)
+          return;
+        if (typeof token === "number") {
+          if (!Array.isArray(current))
+            return;
+          const idx = token < 0 ? current.length + token : token;
+          if (idx < 0 || idx >= current.length)
+            return;
+          current = current[idx];
+        } else {
+          if (typeof current !== "object")
+            return;
+          current = current[token];
+        }
+      }
+      return current;
+    }
+    resolveTemplateContent(templateContent) {
+      const trimmed = templateContent.trim();
+      const tokens = this.tokenizePath(trimmed);
+      if (tokens.length === 0)
+        return;
+      const head = tokens[0];
+      if (head === "input" || head === "inputs") {
+        const rest = tokens.slice(1);
+        if (rest.length === 0)
+          return this.input;
+        return this.navigateTokens(this.input, rest);
+      }
+      if (head === "nodes") {
+        const rest = tokens.slice(1);
+        if (rest.length === 0)
+          return;
+        const nodeId = rest[0];
+        if (typeof nodeId !== "string")
+          return;
+        const nodeValue = getFromMapWithNormalization(this.previousOutputs, nodeId);
+        if (nodeValue === undefined)
+          return;
+        const pathTokens = rest.slice(1);
+        if (pathTokens.length === 0)
+          return this.unwrapAgentNodeResult(nodeValue);
+        if (pathTokens[0] === "output") {
+          if (pathTokens.length === 1) {
+            return this.unwrapAgentNodeResult(nodeValue);
+          }
+          return this.navigateTokens(nodeValue, pathTokens.slice(1));
+        }
+        return this.navigateTokens(nodeValue, pathTokens);
       }
-      if (trimmed !== "input" && trimmed !== "inputs" && trimmed !== "nodes") {
-        const segments = trimmed.split(".");
-        const nodeId = segments[0];
-        const restPath = segments.slice(1).join(".") || undefined;
-        return this.resolveNodePath(`${nodeId}${restPath ? "." + restPath : ""}`);
+      if (typeof head === "string" && head !== "nodes") {
+        const nodeId = head;
+        const nodeValue = getFromMapWithNormalization(this.previousOutputs, nodeId);
+        if (nodeValue === undefined)
+          return;
+        const pathTokens = tokens.slice(1);
+        if (pathTokens.length === 0)
+          return this.unwrapAgentNodeResult(nodeValue);
+        return this.navigateTokens(nodeValue, pathTokens);
       }
       return;
     }
+    unwrapAgentNodeResult(value) {
+      if (value && typeof value === "object" && "result" in value && !("nodes" in value)) {
+        return value.result;
+      }
+      return value;
+    }
     resolveString(template) {
       if (!template || typeof template !== "string") {
         return template;

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

@@ -1,7 +1,7 @@
 import {
   TaskTagPlugin,
   createLarkCliTaskNotifyHook
-} from "./roy-agent-core-q7rt3x8d.js";
+} from "./roy-agent-core-m0cnmg7b.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-7hh0brvs.js";

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

@@ -1,10 +1,10 @@
 import {
   TAG_MAX_COUNT,
   TAG_MIN_COUNT
-} from "./roy-agent-core-p2vpsd1d.js";
+} from "./roy-agent-core-ywtmc0bh.js";
 import {
   validateWorkflowDefinition
-} from "./roy-agent-core-8wd3qwx5.js";
+} from "./roy-agent-core-80e4a3g5.js";
 import {
   AskUserError,
   init_workflow_hil

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

@@ -6,7 +6,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-0n2a8cbn.js";
+} from "./roy-agent-core-nhncpbzz.js";
 import {
   askUserTool,
   createRunWorkflowTool,
@@ -18,10 +18,10 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-mb7b62sm.js";
+} from "./roy-agent-core-r53regz9.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-asp5p3zx.js → roy-agent-core-st9y9z07.js}

@@ -1,6 +1,6 @@
 import {
   createAutoTaskPlugin
-} from "./roy-agent-core-q7rt3x8d.js";
+} from "./roy-agent-core-m0cnmg7b.js";
 import {
   ContextError,
   ErrorCodes

package/dist/shared/@ai-setting/{roy-agent-core-3bdpnmtg.js → roy-agent-core-v5nknfh0.js}

@@ -165,15 +165,8 @@ class AgentRegistry {
     const agent = {
       name,
       type: "sub",
-      description: "Workflow runner — 负责调用 workflow_run 启动 workflow，支持 session resume 和 stop",
+      description: "Workflow runner — 负责调用 workflow_run 启动 workflow，支持 session resume 和 stop；失败接管由 prompt 推理触发 (Task #2251 简化版)。",
       systemPromptRef: "workflow-runner",
-      allowedTools: [
-        "workflow_get",
-        "workflow_list",
-        "workflow_run",
-        "workflow_run_status",
-        "workflow_run_stop"
-      ],
       deniedTools: ["delegate_task", "stop_task"],
       maxIterations: 30
     };

package/dist/shared/@ai-setting/{roy-agent-core-7a3gf3tw.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-ms5dp89r.js";
+} from "./roy-agent-core-apz6v22z.js";
 import {
   runWithBgTaskIdAsync
 } from "./roy-agent-core-c1v263jn.js";
 import {
   DEFAULT_SUBAGENT_PROMPT
-} from "./roy-agent-core-3bdpnmtg.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

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.14",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",