@wichayutdew/pi-workflows 3.0.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wichayutdew/pi-workflows",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "A declarative, pauseable workflow harness for Pi",
   "license": "MIT",
   "repository": {

package/src/engine/run-advance.ts

@@ -33,6 +33,7 @@ const completedStep = (
   ...(run.currentStepOmittedAttempts
     ? { omittedAttempts: run.currentStepOmittedAttempts }
     : {}),
+  ...(run.currentStepUsage ? { usage: run.currentStepUsage } : {}),
   completedAt: now,
 });
 
@@ -126,6 +127,7 @@ export const advanceRun = (
         history: [...run.history, completed],
         currentStepAttempts: undefined,
         currentStepOmittedAttempts: undefined,
+        currentStepUsage: undefined,
         ...(cwd ? { cwd } : {}),
         ...(effects.workspaceCwd ? { restartWorkspaceCwd: undefined } : {}),
         stepHandoff: summary,
@@ -175,6 +177,7 @@ export const advanceRun = (
       history: [...run.history, completed],
       currentStepAttempts: undefined,
       currentStepOmittedAttempts: undefined,
+      currentStepUsage: undefined,
       ...(cwd ? { cwd } : {}),
       ...(effects.workspaceCwd ? { restartWorkspaceCwd: undefined } : {}),
       stepHandoff: preservesGateRevisionContext ? run.stepHandoff : summary,

package/src/engine/run-reconciliation.ts

@@ -100,6 +100,7 @@ export const reconcileRun = (
           history: retainedHistory,
           currentStepAttempts: changedEntry.attempts,
           currentStepOmittedAttempts: changedEntry.omittedAttempts,
+          currentStepUsage: changedEntry.usage,
           visits: rebuildVisits(retainedHistory, restartedStep),
           cwd: retainedWorkspaceCwd(reconciledRun, retainedHistory),
           reviewedArtifact: reviewedApproval?.artifact ?? '',

package/src/engine/run-validation.ts

@@ -22,6 +22,12 @@ import {
   type WorkflowRunStatus,
 } from './state-types.ts';
 import { workflowTraceChars } from './step-trace.ts';
+import {
+  emptyUsageAggregate,
+  isUsageAggregate,
+  mergeUsage,
+  type UsageAggregate,
+} from './usage.ts';
 
 type UnknownRecord = Readonly<Record<string, unknown>>;
 
@@ -140,6 +146,7 @@ const isStepExecutionAttempt = (
     (value.taskTruncated === true) !==
       (typeof value.omittedTaskChars === 'number') ||
     typeof value.startedAt !== 'number' ||
+    (value.usage !== undefined && !isUsageAggregate(value.usage)) ||
     (value.result !== undefined && !isStepAttemptResult(value.result)) ||
     (value.gateDecision !== undefined &&
       !isStepGateDecision(value.gateDecision))
@@ -202,6 +209,20 @@ const isStepExecutionAttempts = (
       );
   });
 
+const usageMatchesAttempts = (
+  attempts: ReadonlyArray<StepExecutionAttempt> | undefined,
+  aggregate: UsageAggregate | undefined,
+  omittedAttempts: unknown,
+): boolean => {
+  if (!aggregate || omittedAttempts !== undefined) return true;
+  const fromAttempts = (attempts ?? []).reduce(
+    (total, attempt) =>
+      attempt.usage ? mergeUsage(total, attempt.usage.models) : total,
+    emptyUsageAggregate(),
+  );
+  return JSON.stringify(fromAttempts) === JSON.stringify(aggregate);
+};
+
 const isStepHistoryEntry = (value: unknown): value is StepHistoryEntry =>
   isRecord(value) &&
   typeof value.stepId === 'string' &&
@@ -215,8 +236,11 @@ const isStepHistoryEntry = (value: unknown): value is StepHistoryEntry =>
       value.artifact === value.approval.artifact)) &&
   (value.attempts === undefined || isStepExecutionAttempts(value.attempts)) &&
   (value.omittedAttempts === undefined ||
-    (Number.isSafeInteger(value.omittedAttempts) &&
-      (value.omittedAttempts as number) > 0)) &&
+    (typeof value.omittedAttempts === 'number' &&
+      Number.isSafeInteger(value.omittedAttempts) &&
+      value.omittedAttempts > 0)) &&
+  (value.usage === undefined || isUsageAggregate(value.usage)) &&
+  usageMatchesAttempts(value.attempts, value.usage, value.omittedAttempts) &&
   typeof value.completedAt === 'number';
 
 const isGateResolution = (value: unknown): value is GateResolution =>
@@ -336,6 +360,8 @@ export const isWorkflowRun = (value: unknown): value is WorkflowRun => {
     (value.currentStepOmittedAttempts === undefined ||
       (Number.isSafeInteger(value.currentStepOmittedAttempts) &&
         (value.currentStepOmittedAttempts as number) > 0)) &&
+    (value.currentStepUsage === undefined ||
+      isUsageAggregate(value.currentStepUsage)) &&
     isVisitCounts(value.visits) &&
     typeof value.startedAt === 'number' &&
     typeof value.updatedAt === 'number' &&
@@ -362,6 +388,16 @@ export const isWorkflowRun = (value: unknown): value is WorkflowRun => {
       value.pausedFrom === 'awaiting-gate');
   if (!hasValidOptionalFields) return false;
 
+  if (
+    !usageMatchesAttempts(
+      value.currentStepAttempts as
+        ReadonlyArray<StepExecutionAttempt> | undefined,
+      value.currentStepUsage as UsageAggregate | undefined,
+      value.currentStepOmittedAttempts,
+    )
+  )
+    return false;
+
   const pendingGate = value.pendingGate;
   if (pendingGate !== undefined && !isPendingGate(pendingGate)) return false;
 

package/src/engine/state-types.ts

@@ -1,3 +1,5 @@
+import type { UsageAggregate } from './usage.ts';
+
 export const RUN_STATE_VERSION = 1 as const;
 export const MAX_GATE_FEEDBACK_CHARS = 50_000;
 export const MAX_RESUME_INPUT_CHARS = 16_000;
@@ -67,6 +69,8 @@ export type StepExecutionAttempt =
       readonly logTruncated?: true | undefined;
       readonly omittedLogEvents?: number | undefined;
       readonly startedAt: number;
+      /** Finalized Pi usage for this exact attempt, if available. */
+      readonly usage?: UsageAggregate | undefined;
       readonly result?: StepAttemptResult | undefined;
       readonly gateDecision?: StepGateDecision | undefined;
     }
@@ -81,6 +85,8 @@ export type StepExecutionAttempt =
       readonly taskTruncated?: true | undefined;
       readonly omittedTaskChars?: number | undefined;
       readonly startedAt: number;
+      /** Finalized Pi usage for this exact attempt, if available. */
+      readonly usage?: UsageAggregate | undefined;
       readonly transcript?: SubagentTranscriptReference | undefined;
       readonly result?: StepAttemptResult | undefined;
       readonly gateDecision?: StepGateDecision | undefined;
@@ -101,6 +107,8 @@ export type StepHistoryEntry = {
   readonly attempts?: ReadonlyArray<StepExecutionAttempt> | undefined;
   /** Older attempts compacted to keep the checkpoint bounded. */
   readonly omittedAttempts?: number | undefined;
+  /** Aggregate usage for this step, including compacted attempts. */
+  readonly usage?: UsageAggregate | undefined;
   readonly completedAt: number;
 };
 
@@ -142,6 +150,8 @@ export type WorkflowRun = {
     ReadonlyArray<StepExecutionAttempt> | undefined;
   /** Older current-step attempts compacted from the checkpoint. */
   readonly currentStepOmittedAttempts?: number | undefined;
+  /** Aggregate usage for the current step, including compacted attempts. */
+  readonly currentStepUsage?: UsageAggregate | undefined;
   readonly startedAt: number;
   readonly updatedAt: number;
   /**

package/src/engine/state.ts

@@ -11,6 +11,15 @@ export {
   MAX_WORKFLOW_TRACE_CHARS,
   RUN_STATE_VERSION,
 } from './state-types.ts';
+export {
+  addUsage,
+  emptyUsage,
+  emptyUsageAggregate,
+  isUsageAggregate,
+  isUsageTotals,
+  mergeUsage,
+  normalizeUsage,
+} from './usage.ts';
 export type {
   GateApproval,
   GateResolution,
@@ -23,3 +32,4 @@ export type {
   WorkflowRun,
   WorkflowRunStatus,
 } from './state-types.ts';
+export type { ModelUsage, UsageAggregate, UsageTotals } from './usage.ts';

package/src/engine/step-trace.ts

@@ -1,6 +1,11 @@
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import { redactStepLogText } from '../step-log.ts';
+import {
+  emptyUsageAggregate,
+  mergeUsage,
+  type UsageAggregate,
+} from './usage.ts';
 import {
   MAX_STEP_TRACE_ARTIFACT_CHARS,
   MAX_STEP_TRACE_ATTEMPTS,
@@ -52,7 +57,8 @@ function attemptSize(attempt: StepExecutionAttempt): number {
       : 0) +
     (attempt.gateDecision?.requestId.length ?? 0) +
     (attempt.gateDecision?.feedback.length ?? 0) +
-    (attempt.gateDecision?.reviewId?.length ?? 0)
+    (attempt.gateDecision?.reviewId?.length ?? 0) +
+    (attempt.usage ? JSON.stringify(attempt.usage).length : 0)
   );
 }
 
@@ -122,10 +128,18 @@ function compactAttempt(attempt: StepExecutionAttempt): StepExecutionAttempt {
 
 /** Returns the bounded checkpoint payload attributable to step traces. */
 export function workflowTraceChars(run: WorkflowRun): number {
-  return [
+  const attempts = [
     ...run.history.flatMap((entry) => entry.attempts ?? []),
     ...(run.currentStepAttempts ?? []),
   ].reduce((total, attempt) => total + attemptSize(attempt), 0);
+  const aggregates = [
+    ...run.history.map((entry) => entry.usage),
+    run.currentStepUsage,
+  ].reduce(
+    (total, usage) => total + (usage ? JSON.stringify(usage).length : 0),
+    0,
+  );
+  return attempts + aggregates;
 }
 
 function compactRunTraceBudget(run: WorkflowRun): WorkflowRun {
@@ -441,6 +455,45 @@ function attemptResult(
 }
 
 /** Stores the submitted result on the latest attempt before transition. */
+/**
+ * Attaches finalized usage to its exact attempt. The separate current
+ * aggregate deliberately survives trace eviction and is copied to history.
+ */
+export function recordCurrentStepUsage(
+  run: WorkflowRun,
+  requestId: string,
+  usage: UsageAggregate,
+  now: number,
+): WorkflowRun {
+  const attempts = run.currentStepAttempts;
+  const index = attempts?.findIndex(
+    (attempt) => attempt.requestId === requestId,
+  );
+  if (index === undefined || index < 0 || !attempts) return run;
+  const attempt = attempts[index];
+  if (!attempt) return run;
+  const currentStepAttempts = [...attempts];
+  currentStepAttempts[index] = {
+    ...attempt,
+    usage: mergeUsage(attempt.usage ?? emptyUsageAggregate(), usage.models),
+  };
+  return compactRunTraceBudget({
+    ...run,
+    currentStepAttempts,
+    currentStepUsage: mergeUsage(
+      run.currentStepUsage ?? emptyUsageAggregate(),
+      usage.models,
+    ),
+    updatedAt: now,
+  });
+}
+
+export function usageAggregateFromModels(
+  entries: UsageAggregate['models'],
+): UsageAggregate {
+  return mergeUsage(emptyUsageAggregate(), entries);
+}
+
 export function recordCurrentStepResult(
   run: WorkflowRun,
   result: WorkflowStepResult,

package/src/engine/usage.ts

@@ -0,0 +1,312 @@
+export type UsageTotals = {
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly cacheReadTokens: number;
+  readonly cacheWriteTokens: number;
+  readonly inputCostUsd: number;
+  readonly outputCostUsd: number;
+  readonly cacheReadCostUsd: number;
+  readonly cacheWriteCostUsd: number;
+  /** Provider-reported cost without a token-category breakdown. */
+  readonly otherCostUsd: number;
+  readonly totalCostUsd: number;
+};
+
+export type ModelUsage = {
+  readonly provider: string;
+  readonly model: string;
+  readonly usage: UsageTotals;
+};
+
+export type UsageAggregate = {
+  readonly usage: UsageTotals;
+  readonly models: ReadonlyArray<ModelUsage>;
+};
+
+type UnknownRecord = Readonly<Record<string, unknown>>;
+const isRecord = (value: unknown): value is UnknownRecord =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export const emptyUsage = (): UsageTotals => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  inputCostUsd: 0,
+  outputCostUsd: 0,
+  cacheReadCostUsd: 0,
+  cacheWriteCostUsd: 0,
+  otherCostUsd: 0,
+  totalCostUsd: 0,
+});
+
+export const emptyUsageAggregate = (): UsageAggregate => ({
+  usage: emptyUsage(),
+  models: [],
+});
+
+const fields = [
+  'inputTokens',
+  'outputTokens',
+  'cacheReadTokens',
+  'cacheWriteTokens',
+  'inputCostUsd',
+  'outputCostUsd',
+  'cacheReadCostUsd',
+  'cacheWriteCostUsd',
+  'otherCostUsd',
+  'totalCostUsd',
+] as const satisfies ReadonlyArray<keyof UsageTotals>;
+
+function finiteNonNegative(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+    ? value
+    : undefined;
+}
+
+function numberAt(
+  value: UnknownRecord,
+  ...keys: ReadonlyArray<string>
+): number {
+  for (const key of keys) {
+    const candidate = finiteNonNegative(value[key]);
+    if (candidate !== undefined) return candidate;
+  }
+  return 0;
+}
+
+function costNumber(
+  value: UnknownRecord,
+  costObj: UnknownRecord | undefined,
+  flatKeys: ReadonlyArray<string>,
+  nestedKey: string,
+): number {
+  for (const key of flatKeys) {
+    const candidate = finiteNonNegative(value[key]);
+    if (candidate !== undefined) return candidate;
+  }
+  if (costObj) {
+    const candidate = finiteNonNegative(costObj[nestedKey]);
+    if (candidate !== undefined) return candidate;
+  }
+  return 0;
+}
+
+function hasMalformedNumber(value: UnknownRecord): boolean {
+  for (const candidate of Object.values(value)) {
+    if (
+      typeof candidate === 'number' &&
+      (!Number.isFinite(candidate) || candidate < 0)
+    ) {
+      return true;
+    }
+    if (isRecord(candidate)) {
+      for (const nested of Object.values(candidate)) {
+        if (
+          typeof nested === 'number' &&
+          (!Number.isFinite(nested) || nested < 0)
+        ) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/** Normalizes Pi usage shapes while rejecting malformed or inconsistent totals. */
+export function normalizeUsage(value: unknown): UsageTotals | undefined {
+  if (!isRecord(value)) return undefined;
+  if (hasMalformedNumber(value)) return undefined;
+
+  const costObj = isRecord(value.cost) ? value.cost : undefined;
+  const flatTotal =
+    finiteNonNegative(value.totalCostUsd) ??
+    (typeof value.cost === 'number'
+      ? finiteNonNegative(value.cost)
+      : undefined) ??
+    finiteNonNegative(value.costUsd);
+  const nestedTotal = costObj ? finiteNonNegative(costObj.total) : undefined;
+  const hasTotal = flatTotal !== undefined || nestedTotal !== undefined;
+  const totalCostUsd = flatTotal ?? nestedTotal ?? 0;
+
+  let usage: UsageTotals = {
+    inputTokens: numberAt(value, 'inputTokens', 'input'),
+    outputTokens: numberAt(value, 'outputTokens', 'output'),
+    cacheReadTokens: numberAt(value, 'cacheReadTokens', 'cacheRead'),
+    cacheWriteTokens: numberAt(value, 'cacheWriteTokens', 'cacheWrite'),
+    inputCostUsd: costNumber(
+      value,
+      costObj,
+      ['inputCostUsd', 'inputCost'],
+      'input',
+    ),
+    outputCostUsd: costNumber(
+      value,
+      costObj,
+      ['outputCostUsd', 'outputCost'],
+      'output',
+    ),
+    cacheReadCostUsd: costNumber(
+      value,
+      costObj,
+      ['cacheReadCostUsd', 'cacheReadCost'],
+      'cacheRead',
+    ),
+    cacheWriteCostUsd: costNumber(
+      value,
+      costObj,
+      ['cacheWriteCostUsd', 'cacheWriteCost'],
+      'cacheWrite',
+    ),
+    otherCostUsd: 0,
+    totalCostUsd,
+  };
+  const recognized = [
+    'inputTokens',
+    'input',
+    'outputTokens',
+    'output',
+    'cacheReadTokens',
+    'cacheRead',
+    'cacheWriteTokens',
+    'cacheWrite',
+    'inputCostUsd',
+    'inputCost',
+    'outputCostUsd',
+    'outputCost',
+    'cacheReadCostUsd',
+    'cacheReadCost',
+    'cacheWriteCostUsd',
+    'cacheWriteCost',
+    'totalCostUsd',
+    'cost',
+    'costUsd',
+  ].some((key) => key in value);
+  if (!recognized) return undefined;
+  const componentCost =
+    usage.inputCostUsd +
+    usage.outputCostUsd +
+    usage.cacheReadCostUsd +
+    usage.cacheWriteCostUsd;
+  if (hasTotal) {
+    if (componentCost > usage.totalCostUsd + 1e-9) return undefined;
+    usage = { ...usage, otherCostUsd: usage.totalCostUsd - componentCost };
+  } else {
+    usage = { ...usage, totalCostUsd: componentCost };
+  }
+  return usage;
+}
+
+export function isUsageTotals(value: unknown): value is UsageTotals {
+  if (
+    !isRecord(value) ||
+    !fields.every((field) => finiteNonNegative(value[field]) !== undefined)
+  )
+    return false;
+  return (
+    Math.abs(
+      (value.inputCostUsd as number) +
+        (value.outputCostUsd as number) +
+        (value.cacheReadCostUsd as number) +
+        (value.cacheWriteCostUsd as number) +
+        (value.otherCostUsd as number) -
+        (value.totalCostUsd as number),
+    ) <= 1e-9
+  );
+}
+
+export function addUsage(left: UsageTotals, right: UsageTotals): UsageTotals {
+  return Object.fromEntries(
+    fields.map((field) => [field, left[field] + right[field]]),
+  ) as UsageTotals;
+}
+
+export function mergeUsage(
+  aggregate: UsageAggregate,
+  entries: ReadonlyArray<ModelUsage>,
+): UsageAggregate {
+  const byModel = new Map(
+    aggregate.models.map((entry) => [
+      `${entry.provider}\0${entry.model}`,
+      entry.usage,
+    ]),
+  );
+  for (const entry of entries) {
+    if (!entry.provider || !entry.model || !isUsageTotals(entry.usage))
+      continue;
+    const key = `${entry.provider}\0${entry.model}`;
+    byModel.set(key, addUsage(byModel.get(key) ?? emptyUsage(), entry.usage));
+  }
+  const models = [...byModel.entries()]
+    .map(([key, usage]) => {
+      const [provider, model] = key.split('\0');
+      return { provider: provider ?? '', model: model ?? '', usage };
+    })
+    .sort((left, right) =>
+      `${left.provider}/${left.model}`.localeCompare(
+        `${right.provider}/${right.model}`,
+      ),
+    );
+  return {
+    usage: models.reduce(
+      (total, entry) => addUsage(total, entry.usage),
+      emptyUsage(),
+    ),
+    models,
+  };
+}
+
+export function isUsageAggregate(value: unknown): value is UsageAggregate {
+  const usage =
+    value && typeof value === 'object'
+      ? (value as UnknownRecord).usage
+      : undefined;
+  const models =
+    value && typeof value === 'object'
+      ? (value as UnknownRecord).models
+      : undefined;
+  if (!isRecord(value) || !isUsageTotals(usage) || !Array.isArray(models))
+    return false;
+  if (
+    !models.every(
+      (entry: unknown) =>
+        isRecord(entry) &&
+        typeof entry.provider === 'string' &&
+        entry.provider.length > 0 &&
+        typeof entry.model === 'string' &&
+        entry.model.length > 0 &&
+        isUsageTotals(entry.usage),
+    )
+  )
+    return false;
+  if (
+    new Set(
+      models.map(
+        (entry) =>
+          `${(entry as ModelUsage).provider}\0${(entry as ModelUsage).model}`,
+      ),
+    ).size !== models.length
+  )
+    return false;
+  const typedModels = models as ReadonlyArray<ModelUsage>;
+  const total = typedModels.reduce(
+    (sum, entry) => addUsage(sum, entry.usage),
+    emptyUsage(),
+  );
+  return fields.every((field) => Math.abs(total[field] - usage[field]) <= 1e-9);
+}
+
+/** Extracts one model-keyed usage record from a Pi message-like payload. */
+export function modelUsageFromMessage(
+  value: unknown,
+  fallbackProvider?: string,
+  fallbackModel?: string,
+): ModelUsage | undefined {
+  if (!isRecord(value)) return undefined;
+  const usage = normalizeUsage(value.usage);
+  const provider =
+    typeof value.provider === 'string' ? value.provider : fallbackProvider;
+  const model = typeof value.model === 'string' ? value.model : fallbackModel;
+  return usage && provider && model ? { provider, model, usage } : undefined;
+}

package/src/harness/action-context.ts

@@ -19,6 +19,7 @@ import type {
 import type { MainStepRuntimeController } from '../runtime/main-step-runtime.ts';
 import type { SerialTaskQueueController } from '../runtime/serial-task-queue.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
+import type { ModelUsage } from '../engine/usage.ts';
 import type { WorkflowStatusSnapshot } from '../workflow-status.ts';
 import type { WorkflowHarnessDependencies } from './dependencies.ts';
 import type { SettledStepReport } from './step-reporting.ts';
@@ -104,11 +105,13 @@ export type HarnessActionContext = {
     identity: MainStepIdentity,
     lines: ReadonlyArray<string>,
     context: ExtensionContext,
+    usage?: ReadonlyArray<ModelUsage>,
   ) => Promise<void>;
   recordMainStepLog: (
     identity: MainStepIdentity,
     lines: ReadonlyArray<string>,
     context: ExtensionContext,
+    usage?: ReadonlyArray<ModelUsage>,
   ) => Promise<void>;
   queueMainStepResult: (
     identity: MainStepIdentity,

package/src/harness/delegation-response-actions.ts

@@ -4,7 +4,11 @@ import {
   type SubagentDelegationUpdate,
 } from '../integrations/subagents/protocol.ts';
 import { advanceRun } from '../engine/transitions.ts';
-import { recordCurrentStepResult } from '../engine/step-trace.ts';
+import {
+  recordCurrentStepResult,
+  recordCurrentStepUsage,
+  usageAggregateFromModels,
+} from '../engine/step-trace.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
 import type { ActiveDelegation } from './types.ts';
@@ -23,6 +27,7 @@ type HarnessActionContext = Pick<
   | 'launchCurrentStep'
   | 'mutationQueue'
   | 'pauseForDelegationFailure'
+  | 'persist'
   | 'releaseMainAfterCancellation'
   | 'retainUnconfirmedDelegation'
   | 'run'
@@ -150,7 +155,22 @@ async function finishDelegation(
     ) {
       return;
     }
+    if (response.requestId !== active.requestId) {
+      throw new Error(
+        'Workflow worker returned an uncorrelated terminal response',
+      );
+    }
     const terminalAt = this.dependencies.now();
+    if (response.usage && response.usage.length > 0) {
+      this.run = recordCurrentStepUsage(
+        this.run,
+        active.requestId,
+        usageAggregateFromModels(response.usage),
+        terminalAt,
+      );
+      this.persist();
+      this.updateStatus();
+    }
     const workflow = this.catalog.workflows.get(this.run.workflowId);
     const step = workflow?.definition.steps[this.run.currentStepId];
     if (!workflow || !step) {