@zhivex-ai/core 0.7.0 → 0.8.0

package/dist/workflow.js

@@ -0,0 +1,727 @@
+import { ValidationError } from "./errors.js";
+const randomId = (prefix) => `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
+const cloneJson = (value) => JSON.parse(JSON.stringify(value));
+export const WORKFLOW_RUN_STATE_SCHEMA_VERSION = 1;
+const toOutput = (state) => ({
+    status: state.status,
+    state: cloneJson(state),
+    outputs: cloneJson(state.outputs),
+    steps: cloneJson(state.steps),
+    session: state.session ? cloneJson(state.session) : undefined
+});
+const createBaseState = (workflow, input) => {
+    const now = Date.now();
+    return {
+        schemaVersion: WORKFLOW_RUN_STATE_SCHEMA_VERSION,
+        workflowId: workflow.id,
+        runId: randomId("wfr"),
+        userId: input.userId,
+        sessionId: input.sessionId ?? randomId("sess"),
+        status: "running",
+        input: input.input === undefined ? undefined : cloneJson(input.input),
+        outputs: {},
+        steps: [],
+        currentStepIndex: 0,
+        metadata: input.metadata ? cloneJson(input.metadata) : undefined,
+        createdAt: now,
+        updatedAt: now
+    };
+};
+export const normalizeWorkflowRunState = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ValidationError("WorkflowRunState must be an object.");
+    }
+    const state = value;
+    if (state.schemaVersion !== undefined && state.schemaVersion > WORKFLOW_RUN_STATE_SCHEMA_VERSION) {
+        throw new ValidationError(`Unsupported WorkflowRunState schemaVersion ${state.schemaVersion}.`);
+    }
+    if (typeof state.runId !== "string" ||
+        typeof state.userId !== "string" ||
+        typeof state.sessionId !== "string" ||
+        typeof state.status !== "string" ||
+        !state.outputs ||
+        typeof state.outputs !== "object" ||
+        Array.isArray(state.outputs) ||
+        !Array.isArray(state.steps) ||
+        typeof state.currentStepIndex !== "number" ||
+        typeof state.createdAt !== "number" ||
+        typeof state.updatedAt !== "number") {
+        throw new ValidationError("WorkflowRunState is missing required fields.");
+    }
+    return {
+        schemaVersion: WORKFLOW_RUN_STATE_SCHEMA_VERSION,
+        workflowId: state.workflowId,
+        runId: state.runId,
+        userId: state.userId,
+        sessionId: state.sessionId,
+        status: state.status,
+        input: state.input === undefined ? undefined : cloneJson(state.input),
+        outputs: cloneJson(state.outputs),
+        steps: cloneJson(state.steps),
+        currentStepIndex: state.currentStepIndex,
+        session: state.session ? cloneJson(state.session) : undefined,
+        metadata: state.metadata ? cloneJson(state.metadata) : undefined,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt
+    };
+};
+export const migrateWorkflowRunState = (value, targetVersion = WORKFLOW_RUN_STATE_SCHEMA_VERSION) => {
+    if (targetVersion !== WORKFLOW_RUN_STATE_SCHEMA_VERSION) {
+        throw new ValidationError(`Unsupported WorkflowRunState migration target ${targetVersion}.`);
+    }
+    return normalizeWorkflowRunState(value);
+};
+const normalizeState = (state) => normalizeWorkflowRunState(state);
+const workflowPersistenceKey = (workflow) => workflow.persistence?.workflowKey ?? workflow.id ?? "default";
+const workflowMetadataKey = (workflow) => workflow.persistence?.metadataKey ?? "workflowRuns";
+const toPersistedWorkflowState = (state) => {
+    const { session: _session, ...persisted } = state;
+    return cloneJson(persisted);
+};
+const getWorkflowRunsMetadata = (metadata, key) => {
+    const value = metadata?.[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? cloneJson(value)
+        : {};
+};
+export const loadWorkflowState = async (workflow, input) => {
+    const definition = validateWorkflow(workflow);
+    const persistence = definition.persistence;
+    if (!persistence) {
+        return undefined;
+    }
+    if (persistence.workflowStateService) {
+        const record = await persistence.workflowStateService.loadWorkflowState({
+            appName: persistence.appName,
+            userId: input.userId,
+            sessionId: input.sessionId,
+            workflowKey: workflowPersistenceKey(definition)
+        });
+        if (!record) {
+            return undefined;
+        }
+        const session = await persistence.sessionService.loadSession({
+            appName: persistence.appName,
+            userId: input.userId,
+            sessionId: input.sessionId
+        });
+        return {
+            ...normalizeWorkflowRunState(record.state),
+            session: session ? cloneJson(session) : undefined
+        };
+    }
+    const session = await persistence.sessionService.loadSession({
+        appName: persistence.appName,
+        userId: input.userId,
+        sessionId: input.sessionId
+    });
+    const runs = getWorkflowRunsMetadata(session?.metadata, workflowMetadataKey(definition));
+    const persisted = runs[workflowPersistenceKey(definition)];
+    if (!persisted || typeof persisted !== "object" || Array.isArray(persisted)) {
+        return undefined;
+    }
+    return {
+        ...normalizeWorkflowRunState(persisted),
+        session: session ? cloneJson(session) : undefined
+    };
+};
+export const saveWorkflowState = async (workflow, state) => {
+    const definition = validateWorkflow(workflow);
+    const persistence = definition.persistence;
+    if (!persistence) {
+        return undefined;
+    }
+    const lookup = {
+        appName: persistence.appName,
+        userId: state.userId,
+        sessionId: state.sessionId
+    };
+    const existing = await persistence.sessionService.loadSession(lookup);
+    const session = existing ??
+        await persistence.sessionService.createSession({
+            ...lookup,
+            metadata: {}
+        });
+    if (persistence.workflowStateService) {
+        const workflowKey = workflowPersistenceKey(definition);
+        await persistence.workflowStateService.saveWorkflowState({
+            ...lookup,
+            workflowKey,
+            state: toPersistedWorkflowState(normalizeWorkflowRunState(state))
+        });
+        const next = {
+            ...session,
+            updatedAt: Date.now(),
+            metadata: {
+                ...(session.metadata ?? {}),
+                workflowStateRefs: {
+                    ...(session.metadata?.workflowStateRefs &&
+                        typeof session.metadata.workflowStateRefs === "object" &&
+                        !Array.isArray(session.metadata.workflowStateRefs)
+                        ? session.metadata.workflowStateRefs
+                        : {}),
+                    [workflowKey]: {
+                        runId: state.runId,
+                        status: state.status,
+                        updatedAt: state.updatedAt
+                    }
+                }
+            }
+        };
+        await persistence.sessionService.saveSession(next);
+        return cloneJson(next);
+    }
+    const metadataKey = workflowMetadataKey(definition);
+    const workflowRuns = getWorkflowRunsMetadata(session.metadata, metadataKey);
+    workflowRuns[workflowPersistenceKey(definition)] = toPersistedWorkflowState(normalizeWorkflowRunState(state));
+    const next = {
+        ...session,
+        updatedAt: Date.now(),
+        metadata: {
+            ...(session.metadata ?? {}),
+            [metadataKey]: workflowRuns
+        }
+    };
+    await persistence.sessionService.saveSession(next);
+    return cloneJson(next);
+};
+const resolveInitialState = async (workflow, input) => {
+    if (input.state) {
+        return normalizeState(input.state);
+    }
+    if (input.resumeFromPersistedState && input.sessionId) {
+        const persisted = await loadWorkflowState(workflow, {
+            userId: input.userId,
+            sessionId: input.sessionId
+        });
+        if (persisted) {
+            return normalizeState(persisted);
+        }
+    }
+    return createBaseState(workflow, input);
+};
+const finalizeWorkflowOutput = async (workflow, state) => {
+    const session = await saveWorkflowState(workflow, state);
+    if (session) {
+        state.session = session;
+    }
+    return toOutput(state);
+};
+const setStepResult = (state, index, result) => {
+    state.steps = [...state.steps.slice(0, index), cloneJson(result)];
+};
+const isParallelStep = (step) => step.kind === "parallel";
+const isLoopStep = (step) => step.kind === "loop";
+const resolveTaskPrompt = async (workflow, state, step, input) => {
+    if (typeof step.prompt === "string") {
+        return step.prompt;
+    }
+    return step.prompt({
+        workflowId: workflow.id,
+        runId: state.runId,
+        userId: state.userId,
+        sessionId: state.sessionId,
+        input: state.input,
+        outputs: cloneJson(state.outputs),
+        steps: cloneJson(state.steps),
+        step,
+        metadata: input.metadata
+    });
+};
+const createStepResult = (step, status, startedAt, output, error) => ({
+    id: step.id,
+    kind: "task",
+    status,
+    outputKey: step.outputKey,
+    outputText: output?.output.steps.at(-1)?.response?.text ?? output?.output.outputText,
+    runId: output?.output.state.runId,
+    agentStatus: output?.output.status,
+    approvals: output?.output.state.pendingApprovals.length ? cloneJson(output.output.state.pendingApprovals) : undefined,
+    startedAt,
+    finishedAt: Date.now(),
+    error: error
+        ? {
+            message: error instanceof Error ? error.message : String(error)
+        }
+        : output?.output.error
+});
+const createParallelResult = (step, status, startedAt, children, error) => ({
+    id: step.id,
+    kind: "parallel",
+    status,
+    children: cloneJson(children),
+    startedAt,
+    finishedAt: Date.now(),
+    error,
+    metadata: step.metadata ? cloneJson(step.metadata) : undefined
+});
+const createLoopResult = (step, status, startedAt, children, error) => ({
+    id: step.id,
+    kind: "loop",
+    status,
+    children: cloneJson(children),
+    startedAt,
+    finishedAt: Date.now(),
+    error,
+    metadata: step.metadata ? cloneJson(step.metadata) : undefined
+});
+const stepStatusFromAgentStatus = (status) => {
+    if (status === "completed") {
+        return "completed";
+    }
+    if (status === "waiting_approval") {
+        return "waiting_approval";
+    }
+    return "failed";
+};
+const validateWorkflow = (definition) => {
+    if (!definition.steps.length) {
+        throw new Error("Workflow must include at least one step.");
+    }
+    const ids = new Set();
+    for (const step of definition.steps) {
+        if (ids.has(step.id)) {
+            throw new Error(`Workflow step id "${step.id}" is duplicated.`);
+        }
+        ids.add(step.id);
+        if (isParallelStep(step)) {
+            if (!step.steps.length) {
+                throw new Error(`Workflow parallel step "${step.id}" must include at least one child step.`);
+            }
+            for (const child of step.steps) {
+                if (isParallelStep(child)) {
+                    throw new Error("Nested parallel workflow steps are not supported yet.");
+                }
+                if (ids.has(child.id)) {
+                    throw new Error(`Workflow step id "${child.id}" is duplicated.`);
+                }
+                ids.add(child.id);
+            }
+            continue;
+        }
+        if (isLoopStep(step)) {
+            if (!Number.isInteger(step.maxIterations) || step.maxIterations <= 0) {
+                throw new Error(`Workflow loop step "${step.id}" must include a positive integer maxIterations.`);
+            }
+            if (step.step.kind === "parallel") {
+                throw new Error("Workflow loop steps can only wrap task steps in this release.");
+            }
+            if (step.step.kind === "loop") {
+                throw new Error("Nested loop workflow steps are not supported yet.");
+            }
+            if (ids.has(step.step.id)) {
+                throw new Error(`Workflow step id "${step.step.id}" is duplicated.`);
+            }
+            ids.add(step.step.id);
+        }
+    }
+    return {
+        ...definition,
+        metadata: definition.metadata ? cloneJson(definition.metadata) : undefined,
+        steps: definition.steps.map((step) => isParallelStep(step)
+            ? {
+                ...step,
+                metadata: step.metadata ? cloneJson(step.metadata) : undefined,
+                steps: step.steps.map((child) => ({
+                    ...child,
+                    metadata: child.metadata ? cloneJson(child.metadata) : undefined
+                }))
+            }
+            : isLoopStep(step)
+                ? {
+                    ...step,
+                    metadata: step.metadata ? cloneJson(step.metadata) : undefined,
+                    step: {
+                        ...step.step,
+                        metadata: step.step.metadata ? cloneJson(step.step.metadata) : undefined
+                    }
+                }
+                : {
+                    ...step,
+                    metadata: step.metadata ? cloneJson(step.metadata) : undefined
+                })
+    };
+};
+export const createWorkflow = (definition) => validateWorkflow(definition);
+const runTaskStep = async (workflow, state, step, input, options) => {
+    const runnerInput = options.isApprovalResume
+        ? {
+            userId: state.userId,
+            sessionId: state.sessionId,
+            approvals: input.approvals,
+            sessionMetadata: input.sessionMetadata,
+            eventMetadata: input.eventMetadata
+        }
+        : {
+            userId: state.userId,
+            sessionId: state.sessionId,
+            prompt: await resolveTaskPrompt(workflow, state, step, input),
+            system: step.system,
+            sessionMetadata: input.sessionMetadata,
+            eventMetadata: {
+                ...(input.eventMetadata ?? {}),
+                workflowRunId: state.runId,
+                workflowStepId: step.id
+            }
+        };
+    const output = await step.runner.run(runnerInput);
+    const status = stepStatusFromAgentStatus(output.output.status);
+    return {
+        result: createStepResult(step, status, options.startedAt, output),
+        output
+    };
+};
+const collectStepOutputs = (outputs, step, result, output) => {
+    if (result.status === "completed" && step.outputKey) {
+        outputs[step.outputKey] = result.outputText ?? output?.output.outputText ?? "";
+    }
+};
+const runParallelStep = async (workflow, state, step, input, existingResult, startedAt) => {
+    const previousChildren = existingResult?.children ?? [];
+    const hasWaitingChild = previousChildren.some((child) => child.status === "waiting_approval");
+    const runnableSteps = step.steps.map((child, childIndex) => {
+        const previous = previousChildren.find((result) => result.id === child.id);
+        if (previous?.status === "completed") {
+            return Promise.resolve({ child, childIndex, result: previous, output: undefined, skipped: true });
+        }
+        if (hasWaitingChild && previous?.status !== "waiting_approval") {
+            return Promise.resolve({
+                child,
+                childIndex,
+                result: previous ?? {
+                    id: child.id,
+                    kind: "task",
+                    status: "pending",
+                    outputKey: child.outputKey,
+                    metadata: child.metadata ? cloneJson(child.metadata) : undefined
+                },
+                output: undefined,
+                skipped: true
+            });
+        }
+        return runTaskStep(workflow, state, child, input, {
+            startedAt: Date.now(),
+            isApprovalResume: previous?.status === "waiting_approval" && Boolean(input.approvals?.length)
+        })
+            .then(({ result, output }) => ({ child, childIndex, result, output, skipped: false }))
+            .catch((error) => ({
+            child,
+            childIndex,
+            result: createStepResult(child, "failed", Date.now(), undefined, error),
+            output: undefined,
+            skipped: false
+        }));
+    });
+    const settled = await Promise.allSettled(runnableSteps);
+    const childRuns = settled.map((settledResult, index) => {
+        if (settledResult.status === "fulfilled") {
+            return settledResult.value;
+        }
+        const child = step.steps[index];
+        return {
+            child,
+            childIndex: index,
+            result: createStepResult(child, "failed", Date.now(), undefined, settledResult.reason),
+            output: undefined,
+            skipped: false
+        };
+    });
+    const children = childRuns
+        .sort((left, right) => left.childIndex - right.childIndex)
+        .map((childRun) => childRun.result);
+    for (const childRun of childRuns) {
+        if (!childRun.skipped) {
+            collectStepOutputs(state.outputs, childRun.child, childRun.result, childRun.output);
+            if (childRun.output?.session) {
+                state.session = childRun.output.session;
+            }
+        }
+    }
+    const waiting = children.some((child) => child.status === "waiting_approval");
+    const failed = children.some((child) => child.status === "failed");
+    const status = waiting ? "waiting_approval" : failed ? "failed" : "completed";
+    const firstError = children.find((child) => child.error)?.error;
+    return {
+        result: createParallelResult(step, step.failFast && failed ? "failed" : status, startedAt, children, firstError),
+        session: state.session
+    };
+};
+const shouldStopLoop = async (workflow, state, step, input, iteration, result) => {
+    if (!step.until) {
+        return false;
+    }
+    return step.until({
+        workflowId: workflow.id,
+        runId: state.runId,
+        userId: state.userId,
+        sessionId: state.sessionId,
+        input: state.input,
+        outputs: cloneJson(state.outputs),
+        steps: cloneJson(state.steps),
+        step,
+        iteration,
+        result: cloneJson(result),
+        metadata: input.metadata
+    });
+};
+const runLoopStep = async (workflow, state, step, input, existingResult, startedAt) => {
+    const previousChildren = existingResult?.children ?? [];
+    const waitingIndex = previousChildren.findIndex((child) => child.status === "waiting_approval");
+    const children = waitingIndex >= 0
+        ? previousChildren.slice(0, waitingIndex)
+        : previousChildren.filter((child) => child.status === "completed");
+    const firstIteration = waitingIndex >= 0 ? waitingIndex : children.length;
+    for (let iteration = firstIteration; iteration < step.maxIterations; iteration += 1) {
+        const childStartedAt = Date.now();
+        const isApprovalResume = waitingIndex === iteration && Boolean(input.approvals?.length);
+        const { result, output } = await runTaskStep(workflow, state, step.step, input, {
+            startedAt: childStartedAt,
+            isApprovalResume
+        }).catch((error) => ({
+            result: createStepResult(step.step, "failed", childStartedAt, undefined, error),
+            output: undefined
+        }));
+        children[iteration] = result;
+        if (output?.session) {
+            state.session = output.session;
+        }
+        if (result.status === "completed") {
+            collectStepOutputs(state.outputs, step.step, result, output);
+            if (await shouldStopLoop(workflow, state, step, input, iteration, result)) {
+                return {
+                    result: createLoopResult(step, "completed", startedAt, children),
+                    session: state.session
+                };
+            }
+            continue;
+        }
+        return {
+            result: createLoopResult(step, result.status === "waiting_approval" ? "waiting_approval" : "failed", startedAt, children, result.error),
+            session: state.session
+        };
+    }
+    return {
+        result: createLoopResult(step, "completed", startedAt, children),
+        session: state.session
+    };
+};
+export const runWorkflow = async (workflow, input) => {
+    const definition = validateWorkflow(workflow);
+    const state = await resolveInitialState(definition, input);
+    state.status = "running";
+    state.updatedAt = Date.now();
+    const waitingIndex = state.steps.findIndex((step) => step.status === "waiting_approval");
+    if (waitingIndex >= 0 && !input.approvals?.length) {
+        state.status = "waiting_approval";
+        state.currentStepIndex = waitingIndex;
+        state.updatedAt = Date.now();
+        return finalizeWorkflowOutput(definition, state);
+    }
+    const startIndex = waitingIndex >= 0 ? waitingIndex : state.currentStepIndex;
+    for (let index = startIndex; index < definition.steps.length; index += 1) {
+        const step = definition.steps[index];
+        const startedAt = Date.now();
+        state.currentStepIndex = index;
+        const existingResult = state.steps[index];
+        setStepResult(state, index, isParallelStep(step)
+            ? {
+                id: step.id,
+                kind: "parallel",
+                status: "running",
+                children: existingResult?.children,
+                metadata: step.metadata ? cloneJson(step.metadata) : undefined,
+                startedAt
+            }
+            : isLoopStep(step)
+                ? {
+                    id: step.id,
+                    kind: "loop",
+                    status: "running",
+                    children: existingResult?.children,
+                    metadata: step.metadata ? cloneJson(step.metadata) : undefined,
+                    startedAt
+                }
+                : {
+                    id: step.id,
+                    kind: "task",
+                    status: "running",
+                    outputKey: step.outputKey,
+                    metadata: step.metadata ? cloneJson(step.metadata) : undefined,
+                    startedAt
+                });
+        try {
+            const stepRun = isParallelStep(step)
+                ? await runParallelStep(definition, state, step, input, existingResult, startedAt)
+                : isLoopStep(step)
+                    ? await runLoopStep(definition, state, step, input, existingResult, startedAt)
+                    : await runTaskStep(definition, state, step, input, {
+                        startedAt,
+                        isApprovalResume: index === waitingIndex && Boolean(input.approvals?.length)
+                    });
+            const { result } = stepRun;
+            const output = "output" in stepRun ? stepRun.output : undefined;
+            const session = "session" in stepRun ? stepRun.session : undefined;
+            if (output?.session) {
+                state.session = output.session;
+            }
+            else if (session) {
+                state.session = session;
+            }
+            const status = result.status;
+            setStepResult(state, index, result);
+            if (status === "completed") {
+                if (!isParallelStep(step) && !isLoopStep(step)) {
+                    collectStepOutputs(state.outputs, step, result, output);
+                }
+                state.currentStepIndex = index + 1;
+                state.updatedAt = Date.now();
+                continue;
+            }
+            state.status = status === "waiting_approval" ? "waiting_approval" : "failed";
+            state.currentStepIndex = index;
+            state.updatedAt = Date.now();
+            return finalizeWorkflowOutput(definition, state);
+        }
+        catch (error) {
+            setStepResult(state, index, isParallelStep(step)
+                ? createParallelResult(step, "failed", startedAt, existingResult?.children ?? [], {
+                    message: error instanceof Error ? error.message : String(error)
+                })
+                : isLoopStep(step)
+                    ? createLoopResult(step, "failed", startedAt, existingResult?.children ?? [], {
+                        message: error instanceof Error ? error.message : String(error)
+                    })
+                    : createStepResult(step, "failed", startedAt, undefined, error));
+            state.status = "failed";
+            state.currentStepIndex = index;
+            state.updatedAt = Date.now();
+            return finalizeWorkflowOutput(definition, state);
+        }
+    }
+    state.status = "completed";
+    state.currentStepIndex = definition.steps.length;
+    state.updatedAt = Date.now();
+    return finalizeWorkflowOutput(definition, state);
+};
+export const replayWorkflowRun = (state) => {
+    const timeline = [
+        {
+            type: "workflow-start",
+            runId: state.runId,
+            workflowId: state.workflowId,
+            createdAt: state.createdAt
+        }
+    ];
+    for (const step of state.steps) {
+        if (step.kind === "parallel") {
+            timeline.push({
+                type: "parallel-start",
+                stepId: step.id,
+                startedAt: step.startedAt
+            });
+            for (const child of step.children ?? []) {
+                if (child.approvals?.length) {
+                    timeline.push({
+                        type: "approval-required",
+                        stepId: child.id,
+                        approvals: cloneJson(child.approvals)
+                    });
+                }
+                timeline.push({
+                    type: "parallel-step-finish",
+                    stepId: child.id,
+                    parentStepId: step.id,
+                    status: child.status,
+                    outputText: child.outputText,
+                    error: child.error,
+                    finishedAt: child.finishedAt
+                });
+            }
+            timeline.push({
+                type: "parallel-finish",
+                stepId: step.id,
+                status: step.status,
+                finishedAt: step.finishedAt
+            });
+            if (step.approvals?.length) {
+                timeline.push({
+                    type: "approval-required",
+                    stepId: step.id,
+                    approvals: cloneJson(step.approvals)
+                });
+            }
+            continue;
+        }
+        if (step.kind === "loop") {
+            timeline.push({
+                type: "loop-start",
+                stepId: step.id,
+                startedAt: step.startedAt
+            });
+            for (const [index, child] of (step.children ?? []).entries()) {
+                if (child.approvals?.length) {
+                    timeline.push({
+                        type: "approval-required",
+                        stepId: child.id,
+                        approvals: cloneJson(child.approvals)
+                    });
+                }
+                timeline.push({
+                    type: "loop-iteration-finish",
+                    stepId: child.id,
+                    parentStepId: step.id,
+                    iteration: index,
+                    status: child.status,
+                    outputText: child.outputText,
+                    error: child.error,
+                    finishedAt: child.finishedAt
+                });
+            }
+            timeline.push({
+                type: "loop-finish",
+                stepId: step.id,
+                status: step.status,
+                finishedAt: step.finishedAt
+            });
+            if (step.approvals?.length) {
+                timeline.push({
+                    type: "approval-required",
+                    stepId: step.id,
+                    approvals: cloneJson(step.approvals)
+                });
+            }
+            continue;
+        }
+        timeline.push({
+            type: "step-start",
+            stepId: step.id,
+            startedAt: step.startedAt
+        });
+        if (step.approvals?.length) {
+            timeline.push({
+                type: "approval-required",
+                stepId: step.id,
+                approvals: cloneJson(step.approvals)
+            });
+        }
+        timeline.push({
+            type: "step-finish",
+            stepId: step.id,
+            status: step.status,
+            outputText: step.outputText,
+            error: step.error,
+            finishedAt: step.finishedAt
+        });
+    }
+    timeline.push({
+        type: "workflow-finish",
+        status: state.status,
+        updatedAt: state.updatedAt
+    });
+    return {
+        status: state.status,
+        timeline,
+        outputs: cloneJson(state.outputs)
+    };
+};
+//# sourceMappingURL=workflow.js.map