Control Flow

Control flow in AgentScope AI Workflows enables structured execution of tasks by managing decision-making, branching, looping, and error handling. Workflows can be dynamically configured to adapt to various execution conditions, ensuring efficient task automation and decision-making logic.

Control Flow Components

AgentScope AI Workflows provide several key control flow mechanisms:

• Conditional Branching: Directs execution based on conditions.

• Loops and Iterations: Repeats tasks until a condition is met.

• Parallel Execution: Runs multiple tasks concurrently.

• Error Handling: Manages exceptions and fallback logic.

---

Conditional Branching

Conditional branching allows workflows to make decisions dynamically. The workflow execution path changes based on specific conditions.

Example: Conditional Execution

import { Workflow, Step } from "@agentscope/core";

const workflow = new Workflow({
  id: "conditional-example",
  steps: {
    checkCondition: new Step({
      run: async ({ context }) => {
        return context.input.value > 10;
      },
    }),
    ifTrue: new Step({
      run: async () => "Value is greater than 10",
    }),
    ifFalse: new Step({
      run: async () => "Value is 10 or less",
    }),
  },
  connections: [
    { from: "checkCondition", to: "ifTrue", condition: (res) => res === true },
    { from: "checkCondition", to: "ifFalse", condition: (res) => res === false },
  ],
});

---

Loops and Iterations

Loops allow workflows to repeat specific steps until a condition is met.

Example: Looping Execution

const workflow = new Workflow({
  id: "loop-example",
  steps: {
    counter: new Step({
      run: async ({ context }) => {
        context.data.count = (context.data.count || 0) + 1;
        return context.data.count;
      },
    }),
    repeatCheck: new Step({
      run: async ({ context }) => context.data.count < 5,
    }),
  },
  connections: [
    { from: "counter", to: "repeatCheck" },
    { from: "repeatCheck", to: "counter", condition: (res) => res === true },
  ],
});

---

Parallel Execution

Parallel execution allows multiple steps to run concurrently, improving efficiency.

Example: Running Steps in Parallel

const workflow = new Workflow({
  id: "parallel-example",
  steps: {
    taskA: new Step({
      run: async () => "Task A completed",
    }),
    taskB: new Step({
      run: async () => "Task B completed",
    }),
  },
  connections: [
    { from: "start", to: ["taskA", "taskB"] },
  ],
});

---

Error Handling

Error handling ensures workflows can gracefully recover from failures.

Example: Try-Catch Execution

const workflow = new Workflow({
  id: "error-handling-example",
  steps: {
    riskyTask: new Step({
      run: async () => {
        throw new Error("Unexpected issue");
      },
    }),
    fallback: new Step({
      run: async () => "Executing fallback logic",
    }),
  },
  connections: [
    { from: "riskyTask", to: "fallback", onError: true },
  ],
});