@owlmeans/agent-common 0.1.18-rc.9 → 0.1.18

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { ResourceRecord } from '@owlmeans/resource'
-import type { ExecutionState } from '@owlmeans/llm-common'
-import type { AgentRunStatus } from './consts.js'
+import { type AgentRunStatus, PipelineRunStatus } from './consts.js'
+import type { Inquiry } from '@owlmeans/llm-common'
 
 /**
  * What a conversation is, as an address.
@@ -43,21 +43,6 @@ export interface ConversationEventInput extends Omit<ConversationEvent, 'id' | '
   createdAt?: string
 }
 
-/**
- * The data plane of a run.
- *
- * `flow` is the serialized {@link import('@owlmeans/flow').FlowModel} state — the control plane
- * collapsed to a string — and `state` is the execution snapshot the LLM layer produces. Keeping
- * them in one record is what makes a resume a single read.
- */
-export interface AgentRunState extends ResourceRecord {
-  id: string
-  conversationId: string
-  flow: string
-  state: ExecutionState
-  updatedAt: string
-}
-
 /**
  * A node of the subsystem memory graph.
  *
@@ -89,16 +74,159 @@ export interface MemoryEventInput extends Omit<MemoryEvent, 'id' | 'seq' | 'crea
 }
 
 /**
- * What a transport carries.
+ * What a transport carries: a POINTER, never a payload.
  *
- * The execution state travels by REFERENCE (`stateRef`), not by value: a project execution's state
- * holds the whole project specification, and a queue whose messages carry that is a queue that
- * falls over on the first large project. The flow string is small enough to inline, and it is what
- * a consumer needs to route the message before it reads anything.
+ * Everything a consumer needs to route the message is here, and everything else is read from the
+ * run row it names. That is not an optimization — a pipeline state is scalars and keys precisely so
+ * that the authority stays in one place, and a message that carried a copy would be a second one,
+ * stale from the moment it was enqueued.
  */
 export interface AgentRunMessage {
-  id: string
+  runId: string
   conversationId: string
-  flow: string
-  stateRef?: string
+  /** The pipeline alias, when the message is about a pipeline run rather than a conversation. */
+  pipeline?: string
+  /** Where the run stood when the message was sent. Advisory — the row is authoritative. */
+  step?: string
+}
+
+/**
+ * What a pipeline carries between its steps.
+ *
+ * Scalars and KEYS — ids, revisions, markers, lists of codes. Never an artifact. Everything large a
+ * pipeline produces belongs in a store of its own and travels here as the key that finds it again:
+ * the state is serialized into the run row at every step boundary, and a state that carries a
+ * document is a row that carries it too, once per step.
+ */
+// Kept as a type: every state shape must satisfy it without declaring an index signature.
+export type PipelineState = Record<string, unknown>
+
+export interface PipelineStepSpec {
+  step: string
+  /**
+   * The steps that must have completed before this one may run.
+   *
+   * Absent or empty means "from the start". Several steps naming the same predecessor fan OUT;
+   * one step naming several predecessors JOINS them. That is the whole edge vocabulary — there is
+   * no conditional edge, because a branch that is expressed as an edge is invisible to a resume,
+   * while a branch expressed as {@link PipelineStep.skipWhen} is the same mechanism that makes a
+   * resume correct.
+   */
+  after?: string[]
+  /** Human-readable, for progress reporting and tool descriptions. */
+  title?: string
+  /** A failure is recorded on the run's `warnings` and the successors still run. */
+  optional?: boolean
+  /**
+   * Re-running repeats a side effect that cannot be undone — a wipe, a purge, a claim against a
+   * rate-limited authority, a model call whose output is already on disk.
+   *
+   * A resume never re-enters one of these on its own; `resume(runId, { from })` refuses without
+   * `force`. It is also refused `attempts > 1`, since an automatic retry is exactly the thing the
+   * flag says must not happen.
+   */
+  nonIdempotent?: boolean
+  /**
+   * Attempts for ONE entry of this step. Default {@link DEFAULT_STEP_ATTEMPTS} = 1.
+   *
+   * Deliberately not a ladder: retry budgets in this family MULTIPLY (an outer 8 around a model's
+   * own inner 8 is 64 real calls), so a step that wants retries asks for them once, here, and the
+   * helpers below it keep theirs.
+   */
+  attempts?: number
+  /** Wall clock for one attempt, in milliseconds. */
+  timeout?: number
+}
+
+export interface PipelineSpec {
+  alias: string
+  /**
+   * Bumped whenever a step is added, removed or renamed.
+   *
+   * `completed` names steps by string, so a run resumed under a changed spec would skip work it
+   * never did — silently, because an unknown name simply matches nothing. A version mismatch is
+   * refused instead.
+   */
+  version: number
+  steps: PipelineStepSpec[]
+}
+
+/**
+ * What a `Waiting` run is waiting for.
+ *
+ * Written by the runner when a step asks a question nobody could answer while it ran, and read by
+ * everything that reports a run — a resume delivers the answer under {@link Inquiry.id}, which is
+ * the only thing that routes it back.
+ */
+export interface PipelineRunInquiry {
+  /** The step that asked. A resume re-enters exactly this one. */
+  step: string
+  askedAt: string
+  inquiry: Inquiry
+}
+
+/**
+ * The data plane of a pipeline run, and the ONE authority on where it stands.
+ *
+ * Not the LangGraph checkpoint: that is a replay optimization which may legitimately be absent (it
+ * is size-guarded and expires), and a design that trusts it has a silent hole exactly where a
+ * crashed run needs an answer. Everything that reads a run's position — a resume, a reconciler, an
+ * operator, a status endpoint — reads this row.
+ *
+ * Timestamps are ISO strings, never `Date`: these records cross process boundaries and storage
+ * backends. A consumer whose store prefers dates maps them at its own adapter boundary.
+ */
+export interface PipelineRun extends ResourceRecord {
+  /** The business key. Chosen by the caller so a run is addressable before it exists. */
+  runId: string
+  pipeline: string
+  version: number
+  /** The subject the run belongs to — for an application with projects, the project id. */
+  scope: string
+  /** The tenant. Carried so a store can refuse a read that crosses an organization. */
+  entityId?: string
+  status: PipelineRunStatus
+  /** Steps that have finished, in the order they finished. */
+  completed: string[]
+  /** Steps that had not run when the run stopped. Empty on a `Done` run. */
+  pending: string[]
+  /** JSON TEXT of {@link PipelineState}. Text, not a subdocument — a state key is a caller's word. */
+  state: string
+  stateChars: number
+  /** What an `optional` step reported when it failed. Never empties a run. */
+  warnings: string[]
+  failedAt?: string
+  error?: string
+  /** The last thing a step said about itself. Progress, not state. */
+  note?: string
+  /**
+   * The question this run stopped on.
+   *
+   * Present only while `status === Waiting`, and cleared on every entry of the run — a row that
+   * kept advertising a question it has already been given would have every reader offer it again.
+   */
+  inquiry?: PipelineRunInquiry
+  /** Whatever lock the run held, so a resume can re-take the same one. */
+  lockTask?: string
+  /** How many times this run has been RESUMED. Reset only by a `Done` outcome. */
+  attempts: number
+  startedAt: string
+  /**
+   * Written at every step boundary — the only signal that separates a run still working from one
+   * whose process died. A reconciler reads staleness here, never the status.
+   */
+  heartbeatAt: string
+  updatedAt: string
+}
+
+/** What the runner reports as it moves. Never persisted as state. */
+export interface PipelineProgress {
+  pipeline: string
+  runId: string
+  step: string
+  /** 1-based position in the topological order. */
+  index: number
+  total: number
+  skipped?: boolean
+  note?: string
 }

package/tests/pipeline.spec.ts

@@ -0,0 +1,164 @@
+import { describe, expect, test } from 'bun:test'
+import { InquiryKind } from '@owlmeans/llm-common'
+import { INQUIRY_ANSWERS_KEY, PipelineRunStatus, makePipelineSpecModel } from '../src/index.js'
+import type { PipelineRun, PipelineSpec } from '../src/index.js'
+
+/**
+ * The spec is the one thing in this family that is checked without a model, a slot or a network, so
+ * every fault it can carry is pinned here. A spec fault that reaches the runner is a build error a
+ * developer reads once; the same fault reaching a deployment is a pipeline that starts and then
+ * cannot say why it did nothing.
+ */
+
+const spec = (steps: PipelineSpec['steps'], version = 1): PipelineSpec =>
+  ({ alias: 'test', version, steps })
+
+describe('agent-common — pipeline spec validation', () => {
+  test('accepts a linear spec', () => {
+    expect(() => makePipelineSpecModel(spec([
+      { step: 'a' }, { step: 'b', after: ['a'] }, { step: 'c', after: ['b'] },
+    ])).validate()).not.toThrow()
+  })
+
+  test('refuses an empty step list, an empty alias and a bad version at once', () => {
+    expect(() => makePipelineSpecModel({ alias: '', version: 0, steps: [] }).validate())
+      .toThrow(/alias is empty.*version.*no steps/s)
+  })
+
+  test('names EVERY fault in one message rather than the first', () => {
+    let message = ''
+    try {
+      makePipelineSpecModel(spec([
+        { step: 'a' },
+        { step: 'a' },
+        { step: 'b', after: ['nope'] },
+        { step: 'c', nonIdempotent: true, attempts: 3 },
+      ])).validate()
+    } catch (e) {
+      message = (e as Error).message
+    }
+    expect(message).toContain('duplicate step "a"')
+    expect(message).toContain('unknown step "nope"')
+    expect(message).toContain('nonIdempotent')
+  })
+
+  test('refuses a step that waits on itself', () => {
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', after: ['a'] }])).validate())
+      .toThrow(/declares itself/)
+  })
+
+  test('refuses a cycle', () => {
+    expect(() => makePipelineSpecModel(spec([
+      { step: 'a', after: ['c'] }, { step: 'b', after: ['a'] }, { step: 'c', after: ['b'] },
+    ])).validate()).toThrow(/cycle/)
+  })
+
+  test('refuses attempts below one and a non-positive timeout', () => {
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', attempts: 0 }])).validate()).toThrow(/attempts/)
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', timeout: 0 }])).validate()).toThrow(/timeout/)
+  })
+
+  test('allows attempts above one on an idempotent step', () => {
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', attempts: 3 }])).validate()).not.toThrow()
+  })
+})
+
+describe('agent-common — pipeline ordering', () => {
+  test('respects `after` and keeps declaration order as the tie-break', () => {
+    // `c` and `b` are both ready after `a`; declaration order decides, not a set's iteration.
+    expect(makePipelineSpecModel(spec([
+      { step: 'a' }, { step: 'c', after: ['a'] }, { step: 'b', after: ['a'] },
+    ])).orderSteps()).toEqual(['a', 'c', 'b'])
+  })
+
+  test('orders a fan-out/join graph so the join comes last', () => {
+    const order = makePipelineSpecModel(spec([
+      { step: 'left' },
+      { step: 'right' },
+      { step: 'deeper', after: ['right'] },
+      { step: 'join', after: ['left', 'deeper'] },
+    ])).orderSteps()
+    expect(order.indexOf('join')).toBe(3)
+    expect(order.indexOf('deeper')).toBeGreaterThan(order.indexOf('right'))
+  })
+
+  test('is stable across calls', () => {
+    const declared = spec([
+      { step: 'a' }, { step: 'b' }, { step: 'c', after: ['a', 'b'] }, { step: 'd', after: ['a'] },
+    ])
+    expect(makePipelineSpecModel(declared).orderSteps()).toEqual(makePipelineSpecModel(declared).orderSteps())
+  })
+
+  test('throws on an unknown `after` and on a cycle', () => {
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', after: ['ghost'] }])).orderSteps()).toThrow(/unknown step/)
+    expect(() => makePipelineSpecModel(spec([
+      { step: 'a', after: ['b'] }, { step: 'b', after: ['a'] },
+    ])).orderSteps()).toThrow(/cycle/)
+  })
+})
+
+describe('agent-common — descendants', () => {
+  const graph = spec([
+    { step: 'a' },
+    { step: 'b', after: ['a'] },
+    { step: 'c', after: ['a'] },
+    { step: 'd', after: ['b', 'c'] },
+    { step: 'aside' },
+  ])
+
+  test('a step and everything that transitively waits on it, in order', () => {
+    expect(makePipelineSpecModel(graph).descendants('b')).toEqual(['b', 'd'])
+    expect(makePipelineSpecModel(graph).descendants('a')).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  test('leaves an unrelated branch alone', () => {
+    expect(makePipelineSpecModel(graph).descendants('b')).not.toContain('aside')
+  })
+
+  test('refuses a step the spec does not declare', () => {
+    expect(() => makePipelineSpecModel(graph).descendants('ghost')).toThrow(/pipeline-step/)
+  })
+
+  test('pipelineStep answers null rather than throwing', () => {
+    expect(makePipelineSpecModel(graph).stepOf('ghost')).toBeNull()
+    expect(makePipelineSpecModel(graph).stepOf('a')?.step).toBe('a')
+  })
+})
+
+describe('agent-common — a run that is waiting for an answer', () => {
+  const waiting = (): PipelineRun => ({
+    runId: 'r', pipeline: 'test', version: 1, scope: 'p1',
+    status: PipelineRunStatus.Waiting,
+    completed: ['a'], pending: ['b'], state: `{"${INQUIRY_ANSWERS_KEY}":{}}`, stateChars: 15,
+    warnings: [], attempts: 0,
+    inquiry: {
+      step: 'b',
+      askedAt: '2026-01-01T00:00:00.000Z',
+      inquiry: {
+        id: 'q1', kind: InquiryKind.Choice, question: 'Which product is this?',
+        options: [{ value: 'a', label: 'A' }, { value: 'b', label: 'B' }],
+      },
+    },
+    startedAt: '2026-01-01T00:00:00.000Z',
+    heartbeatAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+  })
+
+  test('`Waiting` is its own status, distinct from the two that mean the run stopped badly', () => {
+    // A reconciler branches on this string. Aborted means nobody asked anything and a resume may
+    // simply carry on; Waiting means a resume without an answer would park on the same question.
+    expect(PipelineRunStatus.Waiting).toBe('waiting')
+    expect(PipelineRunStatus.Waiting).not.toBe(PipelineRunStatus.Aborted)
+    expect(PipelineRunStatus.Waiting).not.toBe(PipelineRunStatus.Failed)
+  })
+
+  test('a row carrying its inquiry survives the wire unchanged', () => {
+    // These records cross process boundaries and storage backends; the question's id is the ONLY
+    // thing that routes an answer back, so it has to arrive spelled exactly as it was written.
+    const restored = JSON.parse(JSON.stringify(waiting())) as PipelineRun
+
+    expect(restored).toEqual(waiting())
+    expect(restored.inquiry?.inquiry.id).toBe('q1')
+    expect(restored.inquiry?.step).toBe('b')
+  })
+})

package/tests/results.spec.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  CumulativeFactKind, CumulativeResultSource, RESULTS_EVERY_STEP, cumulativeResultsHelper, makePipelineSpecModel,
+} from '../src/index.js'
+import type { CumulativeResultFact, PipelineSpec, RenderableResultEntry } from '../src/index.js'
+
+/**
+ * The pure half of cumulative pipeline results. What a later step is told is rendered here, so
+ * every property a prompt depends on — the same facts give the same bytes, nothing varying leaks
+ * in, a cap drops whole facts and says so — is pinned without a runtime.
+ */
+
+const diamond: PipelineSpec = {
+  alias: 'diamond',
+  version: 1,
+  steps: [
+    { step: 'root' },
+    { step: 'left', after: ['root'] },
+    { step: 'right', after: ['root'] },
+    { step: 'deeper', after: ['right'] },
+    { step: 'join', after: ['left', 'deeper'] },
+    { step: 'aside' },
+  ],
+}
+
+const user: CumulativeResultFact = {
+  kind: CumulativeFactKind.Type, name: 'User', signature: '{ id: string;\n  email: string }',
+  specifier: '@app/common', path: 'sources/common/src/user.ts',
+}
+const create: CumulativeResultFact = {
+  kind: CumulativeFactKind.Endpoint, name: 'user.create', ref: 'User',
+  attrs: { path: '/api/users', method: 'POST' },
+}
+const file: CumulativeResultFact = { kind: CumulativeFactKind.File, name: 'sources/common/src/user.ts' }
+
+const entry = (patch: Partial<RenderableResultEntry> = {}): RenderableResultEntry => ({
+  label: 'types', source: CumulativeResultSource.Extracted, facts: [user, create, file], ...patch,
+})
+
+describe('agent-common — pipeline ancestry', () => {
+  test('names every transitive predecessor in topological order, never the step itself', () => {
+    expect(makePipelineSpecModel(diamond).ancestors('join')).toEqual(['root', 'left', 'right', 'deeper'])
+    expect(makePipelineSpecModel(diamond).ancestors('root')).toEqual([])
+    // The mirror includes the named step; ancestry deliberately does not.
+    expect(makePipelineSpecModel(diamond).descendants('root')).toContain('root')
+  })
+
+  test('carries the SHORTEST distance, so a direct predecessor is depth 1', () => {
+    expect(makePipelineSpecModel(diamond).ancestry('join')).toEqual([
+      { step: 'root', depth: 2 },
+      { step: 'left', depth: 1 },
+      { step: 'right', depth: 2 },
+      { step: 'deeper', depth: 1 },
+    ])
+  })
+
+  test('refuses a step the spec does not declare', () => {
+    expect(() => makePipelineSpecModel(diamond).ancestors('ghost')).toThrow(/pipeline-step/)
+  })
+})
+
+describe('agent-common — rendering an entry', () => {
+  test('the same facts render the same bytes in whatever order they arrive', () => {
+    const one = cumulativeResultsHelper.renderResultEntry(entry())
+    const two = cumulativeResultsHelper.renderResultEntry(entry({ facts: [file, create, user] }))
+
+    expect(two).toEqual(one)
+    expect(one.full).toBe([
+      '### types',
+      '- endpoint `user.create` (method: POST, path: /api/users) → `User`',
+      '- type `User`: { id: string; email: string } — import from `@app/common` (file `sources/common/src/user.ts`)',
+      '- file `sources/common/src/user.ts`',
+    ].join('\n'))
+  })
+
+  test('the names-only form lists names by kind and says it is names only', () => {
+    expect(cumulativeResultsHelper.renderResultEntry(entry()).compact).toBe([
+      '### types (names only)',
+      '- endpoint: `user.create`',
+      '- type: `User`',
+      '- file: `sources/common/src/user.ts`',
+    ].join('\n'))
+  })
+
+  test('over its cap it drops whole facts, never part of one, and says how many', () => {
+    const { full } = cumulativeResultsHelper.renderResultEntry(entry(), { maxChars: 200 })
+
+    expect(full.length).toBeLessThanOrEqual(200)
+    expect(full).toContain('- endpoint `user.create`')
+    expect(full).not.toContain('- type `User`')
+    expect(full).toContain('and 2 more not listed here for space')
+  })
+
+  test('a summary is always labelled unverified, and a summary alone heads the entry so', () => {
+    const withFacts = cumulativeResultsHelper.renderResultEntry(entry({ summary: 'Chose soft deletes.' })).full
+    const alone = cumulativeResultsHelper.renderResultEntry(entry({
+      facts: [], summary: 'Chose soft deletes.', source: CumulativeResultSource.Summarized,
+    })).full
+
+    expect(withFacts).toContain('Summary (not verified — written by a model, never checked against the files): Chose soft deletes.')
+    expect(alone.split('\n')[0]).toBe('### types (not verified)')
+  })
+
+  test('a partial entry says the step failed, and an empty ordinary entry renders nothing', () => {
+    expect(cumulativeResultsHelper.renderResultEntry(entry({ partial: true })).full.split('\n')[0])
+      .toBe('### types (partial: the step failed part-way; only what it left in the files is listed)')
+    expect(cumulativeResultsHelper.renderResultEntry(entry({ facts: [] }))).toEqual({ full: '', compact: '' })
+  })
+})
+
+describe('agent-common — ledger helpers', () => {
+  test('a composed run sorts inside its composing step, ahead of that step\'s own entry', () => {
+    const keys = [[3], [1], [3, 2], [3, 1], [0], [4]]
+    expect([...keys].sort(cumulativeResultsHelper.compareResultOrder)).toEqual([[0], [1], [3, 1], [3, 2], [3], [4]])
+  })
+
+  test('labels a composed run\'s step by its path under the root run', () => {
+    expect(cumulativeResultsHelper.resultLabel('r', 'r', 'types')).toBe('types')
+    expect(cumulativeResultsHelper.resultLabel('r', 'r/design', 'screens')).toBe('design/screens')
+    expect(cumulativeResultsHelper.resultLabel('r', 'r/design/deep', 'x')).toBe('design/deep/x')
+  })
+
+  test('a fact is identified by kind, name and where it comes from', () => {
+    expect(cumulativeResultsHelper.factKey(user)).toBe(cumulativeResultsHelper.factKey({ ...user, signature: 'other' }))
+    expect(cumulativeResultsHelper.factKey(user)).not.toBe(cumulativeResultsHelper.factKey({ ...user, specifier: '@app/other' }))
+  })
+
+  test('a summary answer renders deterministically and is capped after the fact', () => {
+    expect(cumulativeResultsHelper.renderResultSummary({ summary: '  two\nlines  ' })).toBe('two lines')
+    expect(cumulativeResultsHelper.renderResultSummary({ b: ['x', 'y'], a: 1 })).toBe('a: 1; b: x, y')
+    expect(cumulativeResultsHelper.renderResultSummary({ summary: 'word '.repeat(100) }, 40).length).toBeLessThanOrEqual(40)
+  })
+
+  test('merging declarations accumulates extractors and consumers, later scalars win', () => {
+    const merged = cumulativeResultsHelper.mergeResultsSpecs(
+      { window: 1, steps: { types: { extractors: ['ts'], full: ['resources'], maxChars: 100 } } },
+      null,
+      { window: 3, steps: { types: { extractors: ['ts', 'schema'], full: ['endpoints'], maxChars: 200 } } },
+      { steps: { files: { full: RESULTS_EVERY_STEP } } },
+    )
+
+    expect(merged.window).toBe(3)
+    expect(merged.steps?.types).toEqual({
+      extractors: ['ts', 'schema'], full: ['resources', 'endpoints'], maxChars: 200,
+    })
+    expect(merged.steps?.files?.full).toBe(RESULTS_EVERY_STEP)
+  })
+})

package/src/flows.ts

@@ -1,118 +0,0 @@
-import type { ShallowFlow } from '@owlmeans/flow'
-import { AGENT_RUN_FLOW, AgentRunStep, AgentRunTransition } from './consts.js'
-
-/**
- * The lifecycle of one agent run.
- *
- * Read it as "how far did this run get", not "what did it say". Everything conversational happens
- * inside `Working`; the steps exist so that a run interrupted anywhere can be told where to pick
- * up. `Fail` is reachable from every working step, and `Resume` re-enters `Working` from a
- * checkpoint.
- *
- * `service` is left as the flow name on every step. A flow step normally binds to a service or an
- * entrypoint, but an agent run is driven by whoever holds the model — there is no second party to
- * hand control to, and inventing one would put a name in the serialized state that nothing
- * resolves.
- *
- * Each working step keeps exactly ONE non-explicit outgoing transition, so `FlowModel.next()`
- * always has an unambiguous answer: that is what lets a driver advance the run without knowing the
- * vocabulary. `Fail` is marked explicit precisely so it never becomes that automatic answer.
- */
-export const agentRunFlow: ShallowFlow = {
-  flow: AGENT_RUN_FLOW,
-  initialStep: AgentRunStep.Received,
-
-  steps: {
-    [AgentRunStep.Received]: {
-      index: 0,
-      step: AgentRunStep.Received,
-      service: AGENT_RUN_FLOW,
-      initial: true,
-      transitions: {
-        [AgentRunTransition.Prepare]: {
-          transition: AgentRunTransition.Prepare,
-          step: AgentRunStep.Prepared,
-        },
-        [AgentRunTransition.Fail]: {
-          transition: AgentRunTransition.Fail,
-          step: AgentRunStep.Failed,
-          explicit: true,
-        },
-      },
-    },
-
-    [AgentRunStep.Prepared]: {
-      index: 1,
-      step: AgentRunStep.Prepared,
-      service: AGENT_RUN_FLOW,
-      transitions: {
-        [AgentRunTransition.Work]: {
-          transition: AgentRunTransition.Work,
-          step: AgentRunStep.Working,
-        },
-        [AgentRunTransition.Fail]: {
-          transition: AgentRunTransition.Fail,
-          step: AgentRunStep.Failed,
-          explicit: true,
-        },
-      },
-    },
-
-    [AgentRunStep.Working]: {
-      index: 2,
-      step: AgentRunStep.Working,
-      service: AGENT_RUN_FLOW,
-      transitions: {
-        [AgentRunTransition.Finalize]: {
-          transition: AgentRunTransition.Finalize,
-          step: AgentRunStep.Finalizing,
-        },
-        [AgentRunTransition.Fail]: {
-          transition: AgentRunTransition.Fail,
-          step: AgentRunStep.Failed,
-          explicit: true,
-        },
-      },
-    },
-
-    [AgentRunStep.Finalizing]: {
-      index: 3,
-      step: AgentRunStep.Finalizing,
-      service: AGENT_RUN_FLOW,
-      transitions: {
-        [AgentRunTransition.Finish]: {
-          transition: AgentRunTransition.Finish,
-          step: AgentRunStep.Finished,
-        },
-        [AgentRunTransition.Fail]: {
-          transition: AgentRunTransition.Fail,
-          step: AgentRunStep.Failed,
-          explicit: true,
-        },
-      },
-    },
-
-    [AgentRunStep.Finished]: {
-      index: 4,
-      step: AgentRunStep.Finished,
-      service: AGENT_RUN_FLOW,
-      transitions: {},
-    },
-
-    [AgentRunStep.Failed]: {
-      index: 5,
-      step: AgentRunStep.Failed,
-      service: AGENT_RUN_FLOW,
-      transitions: {
-        [AgentRunTransition.Resume]: {
-          transition: AgentRunTransition.Resume,
-          step: AgentRunStep.Working,
-          explicit: true,
-        },
-      },
-    },
-  },
-}
-
-/** Every flow this package declares, for a provider to serve. */
-export const agentFlows: ShallowFlow[] = [agentRunFlow]