@ai-setting/roy-agent-core 1.7.48 → 1.7.50

package/dist/shared/@ai-setting/{roy-agent-core-dabnevwe.js → roy-agent-core-35s1w7tc.js}

@@ -7,7 +7,7 @@ import {
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-jfptxs4f.js";
+} from "./roy-agent-core-6167phd4.js";
 import {
   PythonCallNode,
   SkillNode,
@@ -17,7 +17,7 @@ import {
   init_skill_node,
   init_tool_node,
   init_workflow_node
-} from "./roy-agent-core-yjjqm4ww.js";
+} from "./roy-agent-core-x8n1r7h4.js";
 import {
   WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
   init_json_schema_to_zod,
@@ -26,14 +26,22 @@ import {
   parseWorkflowJsonOutput,
   validateJsonOutputSchema
 } from "./roy-agent-core-1db4vpc6.js";
+import {
+  init_hooks
+} from "./roy-agent-core-fs36xgcs.js";
+import {
+  WorkflowHookPoints,
+  emitWorkflowNodeHook,
+  emitWorkflowRunHook
+} from "./roy-agent-core-9csa89jx.js";
 import {
   TemplateResolver,
   init_template_resolver
-} from "./roy-agent-core-333apxaa.js";
+} from "./roy-agent-core-tjg71zqp.js";
 import {
   DAGManager,
   init_dag_manager
-} from "./roy-agent-core-tm57tmds.js";
+} from "./roy-agent-core-8s9jd2qy.js";
 import {
   WorkflowError,
   createWorkflowEvent,
@@ -49,7 +57,7 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger
@@ -400,6 +408,15 @@ var init_scheduler = __esm(() => {
       log: true
     })
   ], Scheduler.prototype, "getReadyNodes", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.scheduler.markStarted", { recordParams: true, recordResult: false })
+  ], Scheduler.prototype, "markStarted", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.scheduler.markCompleted", { recordParams: true, recordResult: false })
+  ], Scheduler.prototype, "markCompleted", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.scheduler.markFailed", { recordParams: true, recordResult: false })
+  ], Scheduler.prototype, "markFailed", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.scheduler.processEdgesAfterCompletion", {
       recordParams: true,
@@ -786,6 +803,18 @@ var init_executor = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.executeNode", { recordParams: true, recordResult: true })
   ], Executor.prototype, "executeNode", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.executeWithTimeout", { recordParams: true, recordResult: true })
+  ], Executor.prototype, "executeWithTimeout", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.executeWithRetry", { recordParams: true, recordResult: true })
+  ], Executor.prototype, "executeWithRetry", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.cancelNode", { recordParams: true, recordResult: false })
+  ], Executor.prototype, "cancelNode", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.cancelAll", { recordParams: false, recordResult: false })
+  ], Executor.prototype, "cancelAll", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeStart", { recordParams: true, recordResult: true })
   ], Executor.prototype, "writeNodeStart", null);
@@ -1292,97 +1321,7 @@ var init_ask_user_node = __esm(() => {
 });
 
 // src/env/workflow/engine/node-registry.ts
-class NodeRegistry {
-  factories = new Map;
-  toolRegistry;
-  skillRegistry;
-  agentRunner;
-  workflowRunner;
-  agentComponentAdapter;
-  sessionComponent;
-  constructor(options) {
-    const {
-      toolRegistry,
-      skillRegistry,
-      agentComponent,
-      agentRunner,
-      workflowRunner,
-      sessionComponent
-    } = options ?? {};
-    this.toolRegistry = toolRegistry;
-    this.skillRegistry = skillRegistry;
-    this.workflowRunner = workflowRunner;
-    this.sessionComponent = sessionComponent;
-    if (agentRunner) {
-      this.agentRunner = agentRunner;
-      if (agentRunner.setSessionComponent && sessionComponent) {
-        agentRunner.setSessionComponent(sessionComponent);
-      }
-    } else if (agentComponent) {
-      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
-      this.agentRunner = this.agentComponentAdapter;
-    }
-    this.registerBuiltInTypes();
-  }
-  getAgentAdapter() {
-    return this.agentComponentAdapter;
-  }
-  getAgentRunner() {
-    return this.agentRunner;
-  }
-  getSessionComponent() {
-    return this.sessionComponent;
-  }
-  registerBuiltInTypes() {
-    this.factories.set("tool", (definition) => {
-      if (!this.toolRegistry) {
-        throw new Error("ToolRegistry is required for tool nodes");
-      }
-      return new ToolNode(definition, this.toolRegistry);
-    });
-    this.factories.set("skill", (definition) => {
-      if (!this.skillRegistry) {
-        throw new Error("SkillRegistry is required for skill nodes");
-      }
-      return new SkillNode(definition, this.skillRegistry);
-    });
-    this.factories.set("agent", (definition) => {
-      if (!this.agentRunner) {
-        throw new Error("AgentRunner is required for agent nodes");
-      }
-      return new AgentNode(definition, this.agentRunner);
-    });
-    this.factories.set("workflow", (definition) => {
-      if (!this.workflowRunner) {
-        throw new Error("WorkflowRunner is required for workflow nodes");
-      }
-      return new WorkflowNode(definition, this.workflowRunner);
-    });
-    this.factories.set("ask_user", (definition) => {
-      return new AskUserNode(definition);
-    });
-    this.factories.set("python_call", (definition) => {
-      return new PythonCallNode(definition);
-    });
-  }
-  register(type, factory) {
-    this.factories.set(type, factory);
-  }
-  has(type) {
-    return this.factories.has(type);
-  }
-  list() {
-    return Array.from(this.factories.keys());
-  }
-  createNode(definition, context) {
-    const factory = this.factories.get(definition.type);
-    if (!factory) {
-      const availableTypes = this.list().join(", ");
-      throw new Error(`Unknown node type: ${definition.type}. Available types: ${availableTypes}`);
-    }
-    return factory(definition, context);
-  }
-}
+var NodeRegistry;
 var init_node_registry = __esm(() => {
   init_tool_node();
   init_skill_node();
@@ -1391,6 +1330,101 @@ var init_node_registry = __esm(() => {
   init_workflow_node();
   init_ask_user_node();
   init_python_call_node();
+  init_decorator();
+  NodeRegistry = class NodeRegistry {
+    factories = new Map;
+    toolRegistry;
+    skillRegistry;
+    agentRunner;
+    workflowRunner;
+    agentComponentAdapter;
+    sessionComponent;
+    constructor(options) {
+      const {
+        toolRegistry,
+        skillRegistry,
+        agentComponent,
+        agentRunner,
+        workflowRunner,
+        sessionComponent
+      } = options ?? {};
+      this.toolRegistry = toolRegistry;
+      this.skillRegistry = skillRegistry;
+      this.workflowRunner = workflowRunner;
+      this.sessionComponent = sessionComponent;
+      if (agentRunner) {
+        this.agentRunner = agentRunner;
+        if (agentRunner.setSessionComponent && sessionComponent) {
+          agentRunner.setSessionComponent(sessionComponent);
+        }
+      } else if (agentComponent) {
+        this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
+        this.agentRunner = this.agentComponentAdapter;
+      }
+      this.registerBuiltInTypes();
+    }
+    getAgentAdapter() {
+      return this.agentComponentAdapter;
+    }
+    getAgentRunner() {
+      return this.agentRunner;
+    }
+    getSessionComponent() {
+      return this.sessionComponent;
+    }
+    registerBuiltInTypes() {
+      this.factories.set("tool", (definition) => {
+        if (!this.toolRegistry) {
+          throw new Error("ToolRegistry is required for tool nodes");
+        }
+        return new ToolNode(definition, this.toolRegistry);
+      });
+      this.factories.set("skill", (definition) => {
+        if (!this.skillRegistry) {
+          throw new Error("SkillRegistry is required for skill nodes");
+        }
+        return new SkillNode(definition, this.skillRegistry);
+      });
+      this.factories.set("agent", (definition) => {
+        if (!this.agentRunner) {
+          throw new Error("AgentRunner is required for agent nodes");
+        }
+        return new AgentNode(definition, this.agentRunner);
+      });
+      this.factories.set("workflow", (definition) => {
+        if (!this.workflowRunner) {
+          throw new Error("WorkflowRunner is required for workflow nodes");
+        }
+        return new WorkflowNode(definition, this.workflowRunner);
+      });
+      this.factories.set("ask_user", (definition) => {
+        return new AskUserNode(definition);
+      });
+      this.factories.set("python_call", (definition) => {
+        return new PythonCallNode(definition);
+      });
+    }
+    register(type, factory) {
+      this.factories.set(type, factory);
+    }
+    has(type) {
+      return this.factories.has(type);
+    }
+    list() {
+      return Array.from(this.factories.keys());
+    }
+    createNode(definition, context) {
+      const factory = this.factories.get(definition.type);
+      if (!factory) {
+        const availableTypes = this.list().join(", ");
+        throw new Error(`Unknown node type: ${definition.type}. Available types: ${availableTypes}`);
+      }
+      return factory(definition, context);
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.node-registry.createNode", { recordParams: false, recordResult: false })
+  ], NodeRegistry.prototype, "createNode", null);
 });
 
 // src/env/workflow/utils/agent-session-metadata.ts
@@ -1607,6 +1641,7 @@ var init_engine = __esm(() => {
   init_scheduler();
   init_executor();
   init_node_registry();
+  init_hooks();
   init_agent_session_metadata();
   init_logger();
   init_decorator();
@@ -1883,6 +1918,16 @@ var init_engine = __esm(() => {
         workflow_name: sessionState.workflowName,
         input: options?.input
       }));
+      await emitWorkflowRunHook(WorkflowHookPoints.BEFORE_RUN, {
+        runId,
+        sessionId: sessionState.sessionId,
+        workflowId: sessionState.workflowId,
+        workflowName: sessionState.workflowName,
+        status: "running",
+        input: options?.input,
+        totalNodes: this.safeNodeCount(sessionState),
+        completedNodes: sessionState.nodeOutputs.size
+      });
       let pendingNodeId;
       let agentSessionId;
       switch (resumePoint.type) {
@@ -2005,6 +2050,16 @@ var init_engine = __esm(() => {
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.stopped", this.getRunIdFromSessionId(sessionId), {
         reason: stopReason
       }));
+      await emitWorkflowRunHook(WorkflowHookPoints.AFTER_RUN, {
+        runId: this.getRunIdFromSessionId(sessionId),
+        sessionId: sessionState.sessionId,
+        workflowId: sessionState.workflowId,
+        workflowName: sessionState.workflowName,
+        status: "stopped",
+        stopReason,
+        totalNodes: this.safeNodeCount(sessionState),
+        completedNodes: sessionState.nodeOutputs?.size
+      });
       try {
         await sessionState.cancellationScope?.waitForCleanup(force ? 500 : 1500);
       } catch {}
@@ -2353,13 +2408,52 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
         return;
       }
+      await emitWorkflowNodeHook(WorkflowHookPoints.BEFORE_NODE, {
+        runId: context.runId,
+        sessionId: context.sessionId,
+        workflowName: context.workflowName,
+        nodeId,
+        nodeType: nodeDef.type,
+        status: "running",
+        input: context.input,
+        totalNodes: this.safeNodeCount(sessionState),
+        completedNodes: sessionState.nodeOutputs.size,
+        agentSessionId: context.agentSessionId
+      });
       try {
         const result = await executor.executeNode(nodeDef, context);
         if (result.error) {
+          await emitWorkflowNodeHook(WorkflowHookPoints.AFTER_NODE, {
+            runId: context.runId,
+            sessionId: context.sessionId,
+            workflowName: context.workflowName,
+            nodeId,
+            nodeType: nodeDef.type,
+            status: "failed",
+            output: result.output,
+            error: result.error instanceof Error ? result.error.message : String(result.error),
+            durationMs: result.durationMs,
+            totalNodes: this.safeNodeCount(sessionState),
+            completedNodes: sessionState.nodeOutputs.size,
+            agentSessionId: context.agentSessionId
+          });
           return;
         }
         sessionState.nodeOutputs.set(nodeId, result.output);
         scheduler.markCompleted(nodeId);
+        await emitWorkflowNodeHook(WorkflowHookPoints.AFTER_NODE, {
+          runId: context.runId,
+          sessionId: context.sessionId,
+          workflowName: context.workflowName,
+          nodeId,
+          nodeType: nodeDef.type,
+          status: "completed",
+          output: result.output,
+          durationMs: result.durationMs,
+          totalNodes: this.safeNodeCount(sessionState),
+          completedNodes: sessionState.nodeOutputs.size,
+          agentSessionId: context.agentSessionId
+        });
         if (result.output && typeof result.output === "object" && "workflowHistory" in result.output) {
           const messages = result.output.workflowHistory;
           if (Array.isArray(messages)) {
@@ -2528,6 +2622,13 @@ var init_engine = __esm(() => {
         }
       }
     }
+    safeNodeCount(sessionState) {
+      try {
+        return sessionState?.dagManager?.getNodeCount?.();
+      } catch {
+        return;
+      }
+    }
     buildNodeContext(sessionState, nodeId, globalInput) {
       const nodeDef = sessionState.dagManager.getNode(nodeId);
       const runId = this.getRunIdFromSessionId(sessionState.sessionId);
@@ -2620,6 +2721,17 @@ var init_engine = __esm(() => {
         result: finalOutput,
         duration_ms: durationMs
       }), true);
+      await emitWorkflowRunHook(WorkflowHookPoints.AFTER_RUN, {
+        runId,
+        sessionId: sessionState.sessionId,
+        workflowId: sessionState.workflowId,
+        workflowName: sessionState.workflowName,
+        status: "completed",
+        output: finalOutput,
+        durationMs,
+        totalNodes: this.safeNodeCount(sessionState),
+        completedNodes: sessionState.nodeOutputs.size
+      });
       sessionState.resolveCompleted({
         runId,
         status: "completed",
@@ -2653,6 +2765,16 @@ var init_engine = __esm(() => {
         error: { message: error.message, stack: error.stack },
         failed_at: new Date().toISOString()
       }), true);
+      await emitWorkflowRunHook(WorkflowHookPoints.AFTER_RUN, {
+        runId,
+        sessionId: sessionState.sessionId,
+        workflowId: sessionState.workflowId,
+        workflowName: sessionState.workflowName,
+        status: "failed",
+        error: error.message,
+        totalNodes: this.safeNodeCount(sessionState),
+        completedNodes: sessionState.nodeOutputs.size
+      });
       const partialOutput = {};
       for (const [nodeId, nodeOutput] of sessionState.nodeOutputs) {
         partialOutput[nodeId] = nodeOutput;
@@ -2722,6 +2844,9 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.run", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "run", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.initializeSessionState", { recordParams: true, recordResult: true })
+  ], WorkflowEngine.prototype, "initializeSessionState", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.runWithResume", { recordParams: true, recordResult: true })
   ], WorkflowEngine.prototype, "runWithResume", null);
@@ -2734,6 +2859,9 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.stop", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "stop", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.propagateStopToChildSessions", { recordParams: false, recordResult: true })
+  ], WorkflowEngine.prototype, "propagateStopToChildSessions", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true })
   ], WorkflowEngine.prototype, "scheduleAndExecute", null);
@@ -2752,6 +2880,12 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.preExecuteValidation")
   ], WorkflowEngine.prototype, "preExecuteValidation", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.validateAndExecute", { recordParams: true, recordResult: true })
+  ], WorkflowEngine.prototype, "validateAndExecute", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.processConditionalEdgesAfterCompletion", { recordParams: true, recordResult: true })
+  ], WorkflowEngine.prototype, "processConditionalEdgesAfterCompletion", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.buildNodeContext")
   ], WorkflowEngine.prototype, "buildNodeContext", null);

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

@@ -1,12 +1,13 @@
 import {
+  isToolUnavailableError,
   truncateOutputInline
-} from "./roy-agent-core-55hkeft7.js";
+} from "./roy-agent-core-fvs48d38.js";
 import {
   AgentRegistry
-} from "./roy-agent-core-za09t5g3.js";
+} from "./roy-agent-core-rx16h2m1.js";
 import {
   enqueueToAddFakeUserMessage
-} from "./roy-agent-core-4cj6hram.js";
+} from "./roy-agent-core-dv714bqh.js";
 import {
   SessionMessageConverter
 } from "./roy-agent-core-pk1b3kvf.js";
@@ -30,24 +31,24 @@ import {
 } from "./roy-agent-core-7hh0brvs.js";
 import {
   BaseComponent
-} from "./roy-agent-core-ead21w5c.js";
+} from "./roy-agent-core-tdbv7ff4.js";
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-3j4by8rj.js";
+} from "./roy-agent-core-4z3rq5gw.js";
 import {
   init_context
-} from "./roy-agent-core-wn59p0zw.js";
+} from "./roy-agent-core-k8b440n3.js";
 import {
   getCurrentTaskId,
   getEnvContext,
   resolveEnvParentTaskId,
   runWithEnvContextAsync
-} from "./roy-agent-core-zbb3sk72.js";
+} from "./roy-agent-core-5apmk4qw.js";
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger
@@ -857,7 +858,8 @@ class AgentComponent extends BaseComponent {
         resolvedSystemPrompt = eventSourceSystemPrompt;
       }
     }
-    const { snapshot: cacheSnapshot, systemPromptOverride } = await this._loadOrCreateCacheSnapshot(effectiveContext.sessionId, effectiveContext, resolvedSystemPrompt, agent.config.systemPrompt);
+    const useCacheSnapshot = agent.config.type === "primary";
+    const { snapshot: cacheSnapshot, systemPromptOverride } = useCacheSnapshot ? await this._loadOrCreateCacheSnapshot(effectiveContext.sessionId, effectiveContext, resolvedSystemPrompt, agent.config.systemPrompt) : { snapshot: null, systemPromptOverride: undefined };
     if (systemPromptOverride !== undefined) {
       resolvedSystemPrompt = systemPromptOverride;
     } else if (resolvedSystemPrompt) {
@@ -1535,11 +1537,14 @@ class AgentComponent extends BaseComponent {
     logger2.debug(`[executeTool] Available tools: [${ctx.tools.map((t) => t.name).join(", ")}]`);
     const tool = ctx.tools.find((t) => t.name === toolName);
     if (!tool) {
+      logger2.error(`[executeTool] Tool not found: "${toolName}" — agent="${ctx.agent?.name}" (type=${ctx.agent?.config?.type}). Available tools (${ctx.tools.length}): [${ctx.tools.map((t) => t.name).join(", ")}]`);
       this.pushEnvEvent({
         type: "tool.error",
         payload: {
           error: `Tool not found: ${toolName}`,
-          toolName
+          toolName,
+          availableTools: ctx.tools.map((t) => t.name),
+          agentName: ctx.agent?.name
         }
       });
       return {
@@ -1848,7 +1853,18 @@ __legacyDecorateClassTS([
   })
 ], AgentComponent.prototype, "parseToolCallArguments", null);
 __legacyDecorateClassTS([
-  TracedAs("agent.component.executeTool", { recordParams: true, recordResult: true, log: true })
+  TracedAs("agent.component.executeTool", {
+    recordParams: true,
+    recordResult: true,
+    log: true,
+    errorIf: (result) => {
+      const err = result?.result?.error;
+      if (result?.success === false && isToolUnavailableError(err)) {
+        return new Error(String(err));
+      }
+      return;
+    }
+  })
 ], AgentComponent.prototype, "executeTool", null);
 __legacyDecorateClassTS([
   TracedAs("agent.component.recordSessionMessages", { recordParams: true, recordResult: true, log: true })

package/dist/shared/@ai-setting/{roy-agent-core-3j4by8rj.js → roy-agent-core-4z3rq5gw.js}

@@ -1,9 +1,9 @@
 import {
   init_context
-} from "./roy-agent-core-wn59p0zw.js";
+} from "./roy-agent-core-k8b440n3.js";
 import {
   getEnvContext
-} from "./roy-agent-core-zbb3sk72.js";
+} from "./roy-agent-core-5apmk4qw.js";
 import {
   __esm
 } from "./roy-agent-core-fs0mn2jk.js";

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

@@ -1,7 +1,7 @@
 import {
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-jfptxs4f.js → roy-agent-core-6167phd4.js}

@@ -2,6 +2,9 @@ import {
   createSubmitJsonOutputTool,
   init_submit_json_output_tool
 } from "./roy-agent-core-1db4vpc6.js";
+import {
+  init_loose_json
+} from "./roy-agent-core-ze068vc9.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -9,12 +12,12 @@ import {
 import {
   globalHookManager,
   init_global_hook_manager
-} from "./roy-agent-core-3j4by8rj.js";
+} from "./roy-agent-core-4z3rq5gw.js";
 import {
   TracedAs,
   init_decorator,
   wrapFunction
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger
@@ -183,6 +186,7 @@ var init_workflow_json_output_plugin = __esm(() => {
   init_submit_json_output_tool();
   init_logger();
   init_decorator();
+  init_loose_json();
   logger = createLogger("WorkflowJsonOutputPlugin");
   WORKFLOW_JSON_OUTPUT_PLUGIN_KEY = `${WORKFLOW_JSON_OUTPUT_SOURCE_ID}:${WORKFLOW_JSON_OUTPUT_PLUGIN_NAME}`;
   HOOK_NAME = `${WORKFLOW_JSON_OUTPUT_PLUGIN_NAME}:${HOOK_POINT}`;

package/dist/shared/@ai-setting/{roy-agent-core-8nv07zgr.js → roy-agent-core-7evvpfwc.js}

@@ -4,7 +4,7 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-vsrfzaze.js → roy-agent-core-7g03zkkb.js}

@@ -2,7 +2,7 @@ import {
   getEnvContextOrEmpty,
   init_env_context,
   setCurrentTaskId
-} from "./roy-agent-core-zbb3sk72.js";
+} from "./roy-agent-core-5apmk4qw.js";
 import {
   createLogger,
   init_logger

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

@@ -5,7 +5,7 @@ import {
 import {
   TracedAs,
   init_decorator
-} from "./roy-agent-core-a9pbda78.js";
+} from "./roy-agent-core-dsevjbck.js";
 import {
   __esm,
   __legacyDecorateClassTS

package/dist/shared/@ai-setting/{roy-agent-core-4kbvfnn1.js → roy-agent-core-978b6wfx.js}

@@ -1,6 +1,6 @@
 import {
   TagRepository
-} from "./roy-agent-core-pd0exvnq.js";
+} from "./roy-agent-core-nde5gzta.js";
 import {
   exports_search_query_parser,
   init_search_query_parser

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

@@ -0,0 +1,46 @@
+import {
+  init_hook
+} from "./roy-agent-core-qcspfszy.js";
+import {
+  globalHookManager
+} from "./roy-agent-core-4z3rq5gw.js";
+import {
+  __esm
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// src/env/workflow/hooks/workflow-hook-points.ts
+async function emitWorkflowRunHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, {
+    sourceId: "workflow",
+    runId: data.runId,
+    workflowName: data.workflowName,
+    ...metadata
+  });
+}
+async function emitWorkflowNodeHook(hookPoint, data, metadata = {}) {
+  await globalHookManager.execute(hookPoint, data, {
+    sourceId: "workflow",
+    runId: data.runId,
+    workflowName: data.workflowName,
+    nodeId: data.nodeId,
+    ...metadata
+  });
+}
+function getRegisteredWorkflowHookPoints() {
+  return Object.values(WorkflowHookPoints).map((hookPoint) => ({
+    hookPoint,
+    count: globalHookManager.count(hookPoint)
+  }));
+}
+var WorkflowHookPoints;
+var init_workflow_hook_points = __esm(() => {
+  init_hook();
+  WorkflowHookPoints = {
+    BEFORE_RUN: "workflow:before.run",
+    AFTER_RUN: "workflow:after.run",
+    BEFORE_NODE: "workflow:before.node",
+    AFTER_NODE: "workflow:after.node"
+  };
+});
+
+export { WorkflowHookPoints, emitWorkflowRunHook, emitWorkflowNodeHook, getRegisteredWorkflowHookPoints, init_workflow_hook_points };