@radaros/core 0.1.0

package/src/workflow/step-runner.ts

@@ -0,0 +1,303 @@
+import type { RunContext } from "../agent/run-context.js";
+import type {
+  StepDef,
+  StepResult,
+  AgentStep,
+  FunctionStep,
+  ConditionStep,
+  ParallelStep,
+} from "./types.js";
+
+function isAgentStep<T>(step: StepDef<T>): step is AgentStep<T> {
+  return "agent" in step;
+}
+
+function isFunctionStep<T>(step: StepDef<T>): step is FunctionStep<T> {
+  return "run" in step;
+}
+
+function isConditionStep<T>(step: StepDef<T>): step is ConditionStep<T> {
+  return "condition" in step;
+}
+
+function isParallelStep<T>(step: StepDef<T>): step is ParallelStep<T> {
+  return "parallel" in step;
+}
+
+export class StepRunner<TState extends Record<string, unknown>> {
+  private retryPolicy?: { maxRetries: number; backoffMs: number };
+
+  constructor(retryPolicy?: { maxRetries: number; backoffMs: number }) {
+    this.retryPolicy = retryPolicy;
+  }
+
+  async executeSteps(
+    steps: StepDef<TState>[],
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    let currentState = { ...state };
+    const allResults: StepResult[] = [];
+
+    for (const step of steps) {
+      const { state: newState, results } = await this.executeStep(
+        step,
+        currentState,
+        ctx
+      );
+      currentState = newState;
+      allResults.push(...results);
+    }
+
+    return { state: currentState, results: allResults };
+  }
+
+  private async executeStep(
+    step: StepDef<TState>,
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    if (isConditionStep(step)) {
+      return this.executeConditionStep(step, state, ctx);
+    }
+
+    if (isParallelStep(step)) {
+      return this.executeParallelStep(step, state, ctx);
+    }
+
+    if (isAgentStep(step)) {
+      return this.executeAgentStep(step, state, ctx);
+    }
+
+    if (isFunctionStep(step)) {
+      return this.executeFunctionStep(step, state, ctx);
+    }
+
+    return { state, results: [] };
+  }
+
+  private async executeAgentStep(
+    step: AgentStep<TState>,
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    const startTime = Date.now();
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "start",
+    });
+
+    const execute = async (): Promise<StepResult> => {
+      const input = step.inputFrom
+        ? step.inputFrom(state)
+        : JSON.stringify(state);
+
+      const output = await step.agent.run(input, {
+        sessionId: ctx.sessionId,
+      });
+
+      const newState = {
+        ...state,
+        [`${step.name}_output`]: output.text,
+      } as TState;
+
+      Object.assign(state, newState);
+
+      return {
+        stepName: step.name,
+        status: "done",
+        durationMs: Date.now() - startTime,
+      };
+    };
+
+    const result = await this.withRetry(step.name, execute, ctx);
+    return { state, results: [result] };
+  }
+
+  private async executeFunctionStep(
+    step: FunctionStep<TState>,
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    const startTime = Date.now();
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "start",
+    });
+
+    const execute = async (): Promise<StepResult> => {
+      const patch = await step.run(state, ctx);
+      Object.assign(state, patch);
+
+      return {
+        stepName: step.name,
+        status: "done",
+        durationMs: Date.now() - startTime,
+      };
+    };
+
+    const result = await this.withRetry(step.name, execute, ctx);
+    return { state, results: [result] };
+  }
+
+  private async executeConditionStep(
+    step: ConditionStep<TState>,
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    const startTime = Date.now();
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "start",
+    });
+
+    if (step.condition(state)) {
+      const { state: newState, results } = await this.executeSteps(
+        step.steps,
+        state,
+        ctx
+      );
+
+      ctx.eventBus.emit("workflow.step", {
+        runId: ctx.runId,
+        stepName: step.name,
+        status: "done",
+      });
+
+      return {
+        state: newState,
+        results: [
+          {
+            stepName: step.name,
+            status: "done",
+            durationMs: Date.now() - startTime,
+          },
+          ...results,
+        ],
+      };
+    }
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "done",
+    });
+
+    return {
+      state,
+      results: [
+        {
+          stepName: step.name,
+          status: "skipped",
+          durationMs: Date.now() - startTime,
+        },
+      ],
+    };
+  }
+
+  private async executeParallelStep(
+    step: ParallelStep<TState>,
+    state: TState,
+    ctx: RunContext
+  ): Promise<{ state: TState; results: StepResult[] }> {
+    const startTime = Date.now();
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "start",
+    });
+
+    const settled = await Promise.allSettled(
+      step.parallel.map((s) => this.executeStep(s, { ...state }, ctx))
+    );
+
+    const allResults: StepResult[] = [];
+    let mergedState = { ...state };
+
+    for (const result of settled) {
+      if (result.status === "fulfilled") {
+        Object.assign(mergedState, result.value.state);
+        allResults.push(...result.value.results);
+      } else {
+        allResults.push({
+          stepName: step.name,
+          status: "error",
+          error: result.reason?.message ?? "Unknown error",
+          durationMs: Date.now() - startTime,
+        });
+      }
+    }
+
+    ctx.eventBus.emit("workflow.step", {
+      runId: ctx.runId,
+      stepName: step.name,
+      status: "done",
+    });
+
+    return {
+      state: mergedState,
+      results: [
+        {
+          stepName: step.name,
+          status: "done",
+          durationMs: Date.now() - startTime,
+        },
+        ...allResults,
+      ],
+    };
+  }
+
+  private async withRetry(
+    stepName: string,
+    fn: () => Promise<StepResult>,
+    ctx: RunContext
+  ): Promise<StepResult> {
+    const maxRetries = this.retryPolicy?.maxRetries ?? 0;
+    const backoffMs = this.retryPolicy?.backoffMs ?? 1000;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await fn();
+
+        ctx.eventBus.emit("workflow.step", {
+          runId: ctx.runId,
+          stepName,
+          status: "done",
+        });
+
+        return result;
+      } catch (error) {
+        if (attempt === maxRetries) {
+          const err =
+            error instanceof Error ? error : new Error(String(error));
+
+          ctx.eventBus.emit("workflow.step", {
+            runId: ctx.runId,
+            stepName,
+            status: "error",
+          });
+
+          return {
+            stepName,
+            status: "error",
+            error: err.message,
+            durationMs: 0,
+          };
+        }
+
+        await new Promise((resolve) =>
+          setTimeout(resolve, backoffMs * Math.pow(2, attempt))
+        );
+      }
+    }
+
+    return { stepName, status: "error", error: "Exhausted retries", durationMs: 0 };
+  }
+}

package/src/workflow/types.ts

@@ -0,0 +1,55 @@
+import type { Agent } from "../agent/agent.js";
+import type { RunContext } from "../agent/run-context.js";
+import type { StorageDriver } from "../storage/driver.js";
+import type { EventBus } from "../events/event-bus.js";
+
+export type StepDef<TState> =
+  | AgentStep<TState>
+  | FunctionStep<TState>
+  | ConditionStep<TState>
+  | ParallelStep<TState>;
+
+export interface AgentStep<TState> {
+  name: string;
+  agent: Agent;
+  inputFrom?: (state: TState) => string;
+}
+
+export interface FunctionStep<TState> {
+  name: string;
+  run: (state: TState, ctx: RunContext) => Promise<Partial<TState>>;
+}
+
+export interface ConditionStep<TState> {
+  name: string;
+  condition: (state: TState) => boolean;
+  steps: StepDef<TState>[];
+}
+
+export interface ParallelStep<TState> {
+  name: string;
+  parallel: StepDef<TState>[];
+}
+
+export interface WorkflowConfig<
+  TState extends Record<string, unknown> = Record<string, unknown>,
+> {
+  name: string;
+  initialState: TState;
+  steps: StepDef<TState>[];
+  storage?: StorageDriver;
+  retryPolicy?: { maxRetries: number; backoffMs: number };
+  eventBus?: EventBus;
+}
+
+export interface WorkflowResult<TState> {
+  state: TState;
+  stepResults: StepResult[];
+}
+
+export interface StepResult {
+  stepName: string;
+  status: "done" | "error" | "skipped";
+  error?: string;
+  durationMs: number;
+}

package/src/workflow/workflow.ts

@@ -0,0 +1,68 @@
+import { v4 as uuidv4 } from "uuid";
+import { EventBus } from "../events/event-bus.js";
+import { RunContext } from "../agent/run-context.js";
+import { StepRunner } from "./step-runner.js";
+import type { WorkflowConfig, WorkflowResult } from "./types.js";
+
+export class Workflow<
+  TState extends Record<string, unknown> = Record<string, unknown>,
+> {
+  readonly name: string;
+  readonly eventBus: EventBus;
+
+  private config: WorkflowConfig<TState>;
+  private stepRunner: StepRunner<TState>;
+
+  constructor(config: WorkflowConfig<TState>) {
+    this.config = config;
+    this.name = config.name;
+    this.eventBus = config.eventBus ?? new EventBus();
+    this.stepRunner = new StepRunner<TState>(config.retryPolicy);
+  }
+
+  async run(opts?: {
+    sessionId?: string;
+    userId?: string;
+  }): Promise<WorkflowResult<TState>> {
+    const ctx = new RunContext({
+      sessionId: opts?.sessionId ?? uuidv4(),
+      userId: opts?.userId,
+      eventBus: this.eventBus,
+      sessionState: {},
+    });
+
+    this.eventBus.emit("run.start", {
+      runId: ctx.runId,
+      agentName: `workflow:${this.name}`,
+      input: JSON.stringify(this.config.initialState),
+    });
+
+    try {
+      const { state, results } = await this.stepRunner.executeSteps(
+        this.config.steps,
+        { ...this.config.initialState },
+        ctx
+      );
+
+      const workflowResult: WorkflowResult<TState> = {
+        state,
+        stepResults: results,
+      };
+
+      this.eventBus.emit("run.complete", {
+        runId: ctx.runId,
+        output: {
+          text: JSON.stringify(state),
+          toolCalls: [],
+          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+        },
+      });
+
+      return workflowResult;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.eventBus.emit("run.error", { runId: ctx.runId, error: err });
+      throw err;
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}