@voltagent/core 2.4.1 → 2.4.2

package/dist/index.d.mts

@@ -10755,14 +10755,28 @@ interface WorkflowStepForEach<INPUT, DATA, ITEM, RESULT, MAP_DATA = ITEM> extend
     items?: WorkflowStepForEachItemsFunc<INPUT, DATA, ITEM>;
     map?: WorkflowStepForEachMapFunc<INPUT, DATA, ITEM, MAP_DATA>;
 }
-type WorkflowStepLoopConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+type WorkflowStepLoopSteps<INPUT, DATA, RESULT> = readonly [InternalAnyWorkflowStep<INPUT, DATA, RESULT>] | readonly [
+    InternalAnyWorkflowStep<INPUT, DATA, DangerouslyAllowAny>,
+    ...InternalAnyWorkflowStep<INPUT, DangerouslyAllowAny, DangerouslyAllowAny>[],
+    InternalAnyWorkflowStep<INPUT, DangerouslyAllowAny, RESULT>
+];
+type WorkflowStepLoopBaseConfig<INPUT, RESULT> = InternalWorkflowStepConfig<{
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
 }>;
+type WorkflowStepLoopSingleStepConfig<INPUT, DATA, RESULT> = WorkflowStepLoopBaseConfig<INPUT, RESULT> & {
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    steps?: never;
+};
+type WorkflowStepLoopMultiStepConfig<INPUT, DATA, RESULT> = WorkflowStepLoopBaseConfig<INPUT, RESULT> & {
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
+    step?: never;
+};
+type WorkflowStepLoopConfig<INPUT, DATA, RESULT> = WorkflowStepLoopSingleStepConfig<INPUT, DATA, RESULT> | WorkflowStepLoopMultiStepConfig<INPUT, DATA, RESULT>;
 interface WorkflowStepLoop<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT, any, any> {
     type: "loop";
     loopType: "dowhile" | "dountil";
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, DangerouslyAllowAny>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
 }
 type WorkflowStepBranchConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
@@ -11137,7 +11151,8 @@ type LoopType = "dowhile" | "dountil";
 declare function andDoWhile<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<INPUT, DATA, RESULT>): {
     type: "loop";
     loopType: LoopType;
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT> | InternalAnyWorkflowStep<INPUT, DATA, any>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
     execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<RESULT>;
     id: string;
@@ -11151,7 +11166,8 @@ declare function andDoWhile<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<
 declare function andDoUntil<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<INPUT, DATA, RESULT>): {
     type: "loop";
     loopType: LoopType;
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT> | InternalAnyWorkflowStep<INPUT, DATA, any>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
     execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<RESULT>;
     id: string;

package/dist/index.d.ts

@@ -10755,14 +10755,28 @@ interface WorkflowStepForEach<INPUT, DATA, ITEM, RESULT, MAP_DATA = ITEM> extend
     items?: WorkflowStepForEachItemsFunc<INPUT, DATA, ITEM>;
     map?: WorkflowStepForEachMapFunc<INPUT, DATA, ITEM, MAP_DATA>;
 }
-type WorkflowStepLoopConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+type WorkflowStepLoopSteps<INPUT, DATA, RESULT> = readonly [InternalAnyWorkflowStep<INPUT, DATA, RESULT>] | readonly [
+    InternalAnyWorkflowStep<INPUT, DATA, DangerouslyAllowAny>,
+    ...InternalAnyWorkflowStep<INPUT, DangerouslyAllowAny, DangerouslyAllowAny>[],
+    InternalAnyWorkflowStep<INPUT, DangerouslyAllowAny, RESULT>
+];
+type WorkflowStepLoopBaseConfig<INPUT, RESULT> = InternalWorkflowStepConfig<{
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
 }>;
+type WorkflowStepLoopSingleStepConfig<INPUT, DATA, RESULT> = WorkflowStepLoopBaseConfig<INPUT, RESULT> & {
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    steps?: never;
+};
+type WorkflowStepLoopMultiStepConfig<INPUT, DATA, RESULT> = WorkflowStepLoopBaseConfig<INPUT, RESULT> & {
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
+    step?: never;
+};
+type WorkflowStepLoopConfig<INPUT, DATA, RESULT> = WorkflowStepLoopSingleStepConfig<INPUT, DATA, RESULT> | WorkflowStepLoopMultiStepConfig<INPUT, DATA, RESULT>;
 interface WorkflowStepLoop<INPUT, DATA, RESULT> extends InternalBaseWorkflowStep<INPUT, DATA, RESULT, any, any> {
     type: "loop";
     loopType: "dowhile" | "dountil";
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, DangerouslyAllowAny>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
 }
 type WorkflowStepBranchConfig<INPUT, DATA, RESULT> = InternalWorkflowStepConfig<{
@@ -11137,7 +11151,8 @@ type LoopType = "dowhile" | "dountil";
 declare function andDoWhile<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<INPUT, DATA, RESULT>): {
     type: "loop";
     loopType: LoopType;
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT> | InternalAnyWorkflowStep<INPUT, DATA, any>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
     execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<RESULT>;
     id: string;
@@ -11151,7 +11166,8 @@ declare function andDoWhile<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<
 declare function andDoUntil<INPUT, DATA, RESULT>(config: WorkflowStepLoopConfig<INPUT, DATA, RESULT>): {
     type: "loop";
     loopType: LoopType;
-    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT>;
+    step: InternalAnyWorkflowStep<INPUT, DATA, RESULT> | InternalAnyWorkflowStep<INPUT, DATA, any>;
+    steps: WorkflowStepLoopSteps<INPUT, DATA, RESULT>;
     condition: InternalWorkflowFunc<INPUT, RESULT, boolean, any, any>;
     execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<RESULT>;
     id: string;

package/dist/index.js

@@ -3166,47 +3166,78 @@ function andBranch({
 __name(andBranch, "andBranch");
 
 // src/workflow/steps/and-loop.ts
-var createLoopStep = /* @__PURE__ */ __name((loopType, { step, condition, ...config }) => {
-  const finalStep = matchStep(step);
+function splitLoopConfig(config) {
+  if ("step" in config) {
+    const { step: _step, condition: condition2, ...stepConfig2 } = config;
+    return { condition: condition2, stepConfig: stepConfig2 };
+  }
+  const { steps: _steps, condition, ...stepConfig } = config;
+  return { condition, stepConfig };
+}
+__name(splitLoopConfig, "splitLoopConfig");
+function getLoopSteps(config) {
+  if ("steps" in config && config.steps) {
+    if (config.steps.length === 0) {
+      throw new Error("andDoWhile/andDoUntil requires at least one step");
+    }
+    return config.steps;
+  }
+  return [config.step];
+}
+__name(getLoopSteps, "getLoopSteps");
+var createLoopStep = /* @__PURE__ */ __name((loopType, config) => {
+  const { condition, stepConfig } = splitLoopConfig(config);
+  const loopSteps = getLoopSteps(config);
+  const resolvedSteps = loopSteps.map((loopStep) => matchStep(loopStep));
+  const firstStep = loopSteps[0];
+  if (!firstStep) {
+    throw new Error("andDoWhile/andDoUntil requires at least one step");
+  }
   return {
-    ...defaultStepConfig(config),
+    ...defaultStepConfig(stepConfig),
     type: "loop",
     loopType,
-    step,
+    step: firstStep,
+    steps: loopSteps,
     condition,
     execute: /* @__PURE__ */ __name(async (context8) => {
       const { state } = context8;
       const traceContext = state.workflowContext?.traceContext;
       let currentData = context8.data;
       let iteration = 0;
-      while (true) {
-        throwIfAborted(state.signal);
+      const runResolvedStep = /* @__PURE__ */ __name(async (stepIndex) => {
+        const resolvedStep = resolvedSteps[stepIndex];
+        if (!resolvedStep) {
+          return;
+        }
         let childSpan;
         if (traceContext) {
+          const isSingleLoopStep = resolvedSteps.length === 1;
           childSpan = traceContext.createStepSpan(
-            iteration,
-            finalStep.type,
-            finalStep.name || finalStep.id || `Loop ${iteration + 1}`,
+            iteration * resolvedSteps.length + stepIndex,
+            resolvedStep.type,
+            resolvedStep.name || resolvedStep.id || (isSingleLoopStep ? `Loop ${iteration + 1}` : `Loop ${iteration + 1}.${stepIndex + 1}`),
             {
-              parentStepId: config.id,
-              parallelIndex: iteration,
+              parentStepId: stepConfig.id,
+              parallelIndex: isSingleLoopStep ? iteration : stepIndex,
               input: currentData,
               attributes: {
                 "workflow.step.loop": true,
                 "workflow.step.parent_type": "loop",
-                "workflow.step.loop_type": loopType
+                "workflow.step.loop_type": loopType,
+                "workflow.step.loop_iteration": iteration,
+                "workflow.step.loop_step_index": stepIndex
               }
             }
           );
         }
-        const subState = {
-          ...state,
-          workflowContext: void 0
-        };
-        const executeStep = /* @__PURE__ */ __name(() => finalStep.execute({
+        const executeStep = /* @__PURE__ */ __name(() => resolvedStep.execute({
           ...context8,
           data: currentData,
-          state: subState
+          state: {
+            ...state,
+            workflowContext: void 0
+          }
         }), "executeStep");
         try {
           currentData = childSpan && traceContext ? await traceContext.withSpan(childSpan, executeStep) : await executeStep();
@@ -3219,6 +3250,13 @@ var createLoopStep = /* @__PURE__ */ __name((loopType, { step, condition, ...con
           }
           throw error;
         }
+      }, "runResolvedStep");
+      while (true) {
+        throwIfAborted(state.signal);
+        for (let stepIndex = 0; stepIndex < resolvedSteps.length; stepIndex += 1) {
+          throwIfAborted(state.signal);
+          await runResolvedStep(stepIndex);
+        }
         iteration += 1;
         throwIfAborted(state.signal);
         const shouldContinue = await condition({
@@ -11043,6 +11081,7 @@ function serializeWorkflowStep(step, index) {
     }
     case "loop": {
       const loopStep = step;
+      const serializedSteps = loopStep.steps && Array.isArray(loopStep.steps) ? loopStep.steps.map((subStep, subIndex) => serializeWorkflowStep(subStep, subIndex)) : loopStep.step ? [serializeWorkflowStep(loopStep.step, 0)] : [];
       return {
         ...baseStep,
         ...loopStep.condition && {
@@ -11051,8 +11090,12 @@ function serializeWorkflowStep(step, index) {
         ...loopStep.loopType && {
           loopType: loopStep.loopType
         },
-        ...loopStep.step && {
-          nestedStep: serializeWorkflowStep(loopStep.step, 0)
+        ...serializedSteps.length === 1 && {
+          nestedStep: serializedSteps[0]
+        },
+        ...serializedSteps.length > 1 && {
+          subSteps: serializedSteps,
+          subStepsCount: serializedSteps.length
         }
       };
     }
@@ -29057,6 +29100,9 @@ var Agent = class {
       },
       options.logger
     );
+    if (this.voltOpsClient && !AgentRegistry.getInstance().getGlobalVoltOpsClient()) {
+      AgentRegistry.getInstance().setGlobalVoltOpsClient(this.voltOpsClient);
+    }
     this.logger.debug(`Agent created: ${this.name}`, {
       event: LogEvents.AGENT_CREATED,
       agentId: this.id,