@owlmeans/agent-common 0.1.18-rc.47 → 0.1.18-rc.49

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { ResourceRecord } from '@owlmeans/resource'
-import { type AgentRunStatus, RESULTS_EVERY_STEP, CumulativeResultSource, PipelineRunStatus } from './consts.js'
+import { type AgentRunStatus, PipelineRunStatus } from './consts.js'
 import type { Inquiry } from '@owlmeans/llm-common'
 
 /**
@@ -98,6 +98,7 @@ export interface AgentRunMessage {
  * 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 {
@@ -229,149 +230,3 @@ export interface PipelineProgress {
   skipped?: boolean
   note?: string
 }
-
-/**
- * ONE authoritative fact about what a step produced, small enough to be one line of a prompt.
- *
- * Every field is optional past `kind` and `name`, because facts differ in what matters about them:
- * a type has a shape and an import specifier, an endpoint an alias, a method, a path and a guard, a
- * resource a table and an accessor, a file only its path. Put scalars that have no field of their
- * own into `attrs`.
- */
-export interface CumulativeResultFact {
-  /** What the fact is about — see {@link CumulativeFactKind}. */
-  kind: string
-  /** The name to use VERBATIM. */
-  name: string
-  /** The file it lives in, relative to the project root. */
-  path?: string
-  /** The module specifier it is imported from. */
-  specifier?: string
-  /** Its shape or signature, on one line. */
-  signature?: string
-  /** Fields, parameters or columns, when there is no signature to say it. */
-  members?: string[]
-  /** Another fact's name this one points at — a returned type, a mapped table. */
-  ref?: string
-  /** Scalars without a field of their own — `method`, `path`, `guard`, `table`. */
-  attrs?: Record<string, string>
-}
-
-/**
- * One step's contribution to a ledger.
- *
- * Keyed by `(ledger, runId, step)`. `order` places it in the ledger: the topological index of the
- * step in its own pipeline, preceded by the index path of every step it was composed under, so a
- * run composed as a step of another sorts inside that step, ahead of the composing step's own
- * entry. A single number cannot say that: two pipelines' indexes are not comparable.
- *
- * `full` and `compact` are rendered once, when the entry is written, and never contain a timestamp,
- * a run id or anything else a model would copy without meaning to.
- */
-export interface CumulativeResultEntry extends ResourceRecord {
-  /** What entries can see each other — by default the root run of the composition. */
-  ledger: string
-  pipeline: string
-  runId: string
-  step: string
-  /** How the entry is headed in a prompt: the step, behind the path of the steps it runs under. */
-  label: string
-  order: number[]
-  /** Bumped every time the entry is re-extracted after a later step rewrote one of its files. */
-  revision: number
-  source: CumulativeResultSource
-  /** An `optional` step that failed: whatever it left behind, and a heading that says so. */
-  partial?: boolean
-  facts: CumulativeResultFact[]
-  /** The files the facts were read from — what a later rewrite is matched against. */
-  files: string[]
-  /** A model's summary, rendered and capped. NOT verified, and always labelled so. */
-  summary?: string
-  full: string
-  compact: string
-  /** Consumers that always get the full entry, by step name, or every later step. */
-  fullFor?: string[] | typeof RESULTS_EVERY_STEP
-  /** Consumers that never see the entry in their prompt. */
-  omitFor?: string[]
-  /** How many edges back the entry is still rendered in full by default. */
-  window?: number
-  updatedAt: string
-}
-
-/**
- * The optional model-written summary of a step. OFF unless a step declares one.
- *
- * Facts are the product; a summary is for what code cannot extract — an intent, a decision taken.
- * It is bounded by `maxChars` in code after the model answers, rendered deterministically from the
- * schema-shaped answer, and always labelled as unverified wherever it is shown.
- */
-export interface ResultSummarySpec {
-  /** Which model — interpreted by the caller's summarize callback (a model role, typically). */
-  role?: string
-  instructions: string
-  /** JSON schema of the answer. Absent means `{ summary: string }`. */
-  schema?: Record<string, unknown>
-  /** Defaults to `DEFAULT_RESULT_SUMMARY_CHARS`. */
-  maxChars?: number
-}
-
-/**
- * What one step contributes, and to whom. JSON-safe, so a declaration can live in data.
- *
- * Extractors are named, never inlined: a declaration names what runs, and the runtime holds the
- * code. A consumer not named in `full` or `omit` gets the full entry within `window` edges and the
- * names only beyond it.
- */
-export interface StepResultsSpec {
-  /** Named deterministic extractors, run in this order. */
-  extractors?: string[]
-  /** Later steps that get the FULL entry wherever they sit, or `'*'` for all of them. */
-  full?: string[] | typeof RESULTS_EVERY_STEP
-  /** Later steps that are never shown the entry. */
-  omit?: string[]
-  /** Overrides {@link CumulativeResultsSpec.window} for this entry. */
-  window?: number
-  /** Cap on the full rendering; facts are dropped whole, never cut. */
-  maxChars?: number
-  /** Cap on the names-only rendering. */
-  maxCompactChars?: number
-  /** Re-extract this entry when a later step rewrites one of its files. Defaults to the spec's. */
-  refresh?: boolean
-  summary?: ResultSummarySpec
-}
-
-/** The pipeline-level declaration — merged from a pipeline's own and any overlay with {@link mergeResultsSpecs}. */
-export interface CumulativeResultsSpec {
-  /** Per step, by step name. A step with no entry contributes only what it records itself. */
-  steps?: Record<string, StepResultsSpec>
-  /** Default {@link DEFAULT_RESULTS_WINDOW}. */
-  window?: number
-  /** Total characters of one view. Default `DEFAULT_RESULTS_MAX_CHARS`. */
-  maxChars?: number
-  /** Default cap of one full entry. Default {@link DEFAULT_RESULT_ENTRY_CHARS}. */
-  maxEntryChars?: number
-  /** Default cap of one names-only entry. Default {@link DEFAULT_RESULT_COMPACT_CHARS}. */
-  maxCompactChars?: number
-  /** Default for {@link StepResultsSpec.refresh}. Defaults to `true`. */
-  refresh?: boolean
-}
-
-/** What a facts query may narrow by. Every field is an exact match. */
-export interface ResultFactQuery {
-  kind?: string
-  name?: string
-  /** A producing step, by its name or by its label. */
-  step?: string
-}
-
-/** What {@link renderResultEntry} needs of an entry. */
-export type RenderableResultEntry = Pick<
-  CumulativeResultEntry, 'label' | 'source' | 'partial' | 'facts' | 'summary'
->
-
-export interface ResultRenderCaps {
-  /** Cap on the full rendering. Default {@link DEFAULT_RESULT_ENTRY_CHARS}. */
-  maxChars?: number
-  /** Cap on the names-only rendering. Default {@link DEFAULT_RESULT_COMPACT_CHARS}. */
-  maxCompactChars?: number
-}

package/tests/pipeline.spec.ts

@@ -1,9 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import { InquiryKind } from '@owlmeans/llm-common'
-import {
-  INQUIRY_ANSWERS_KEY, PipelineRunStatus,
-  orderPipelineSteps, pipelineDescendants, pipelineStep, validatePipelineSpec,
-} from '../src/index.js'
+import { INQUIRY_ANSWERS_KEY, PipelineRunStatus, makePipelineSpecModel } from '../src/index.js'
 import type { PipelineRun, PipelineSpec } from '../src/index.js'
 
 /**
@@ -18,25 +15,25 @@ const spec = (steps: PipelineSpec['steps'], version = 1): PipelineSpec =>
 
 describe('agent-common — pipeline spec validation', () => {
   test('accepts a linear spec', () => {
-    expect(() => validatePipelineSpec(spec([
+    expect(() => makePipelineSpecModel(spec([
       { step: 'a' }, { step: 'b', after: ['a'] }, { step: 'c', after: ['b'] },
-    ]))).not.toThrow()
+    ])).validate()).not.toThrow()
   })
 
   test('refuses an empty step list, an empty alias and a bad version at once', () => {
-    expect(() => validatePipelineSpec({ alias: '', version: 0, steps: [] }))
+    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 {
-      validatePipelineSpec(spec([
+      makePipelineSpecModel(spec([
         { step: 'a' },
         { step: 'a' },
         { step: 'b', after: ['nope'] },
         { step: 'c', nonIdempotent: true, attempts: 3 },
-      ]))
+      ])).validate()
     } catch (e) {
       message = (e as Error).message
     }
@@ -46,41 +43,41 @@ describe('agent-common — pipeline spec validation', () => {
   })
 
   test('refuses a step that waits on itself', () => {
-    expect(() => validatePipelineSpec(spec([{ step: 'a', after: ['a'] }])))
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', after: ['a'] }])).validate())
       .toThrow(/declares itself/)
   })
 
   test('refuses a cycle', () => {
-    expect(() => validatePipelineSpec(spec([
+    expect(() => makePipelineSpecModel(spec([
       { step: 'a', after: ['c'] }, { step: 'b', after: ['a'] }, { step: 'c', after: ['b'] },
-    ]))).toThrow(/cycle/)
+    ])).validate()).toThrow(/cycle/)
   })
 
   test('refuses attempts below one and a non-positive timeout', () => {
-    expect(() => validatePipelineSpec(spec([{ step: 'a', attempts: 0 }]))).toThrow(/attempts/)
-    expect(() => validatePipelineSpec(spec([{ step: 'a', timeout: 0 }]))).toThrow(/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(() => validatePipelineSpec(spec([{ step: 'a', attempts: 3 }]))).not.toThrow()
+    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(orderPipelineSteps(spec([
+    expect(makePipelineSpecModel(spec([
       { step: 'a' }, { step: 'c', after: ['a'] }, { step: 'b', after: ['a'] },
-    ]))).toEqual(['a', 'c', 'b'])
+    ])).orderSteps()).toEqual(['a', 'c', 'b'])
   })
 
   test('orders a fan-out/join graph so the join comes last', () => {
-    const order = orderPipelineSteps(spec([
+    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'))
   })
@@ -89,14 +86,14 @@ describe('agent-common — pipeline ordering', () => {
     const declared = spec([
       { step: 'a' }, { step: 'b' }, { step: 'c', after: ['a', 'b'] }, { step: 'd', after: ['a'] },
     ])
-    expect(orderPipelineSteps(declared)).toEqual(orderPipelineSteps(declared))
+    expect(makePipelineSpecModel(declared).orderSteps()).toEqual(makePipelineSpecModel(declared).orderSteps())
   })
 
   test('throws on an unknown `after` and on a cycle', () => {
-    expect(() => orderPipelineSteps(spec([{ step: 'a', after: ['ghost'] }]))).toThrow(/unknown step/)
-    expect(() => orderPipelineSteps(spec([
+    expect(() => makePipelineSpecModel(spec([{ step: 'a', after: ['ghost'] }])).orderSteps()).toThrow(/unknown step/)
+    expect(() => makePipelineSpecModel(spec([
       { step: 'a', after: ['b'] }, { step: 'b', after: ['a'] },
-    ]))).toThrow(/cycle/)
+    ])).orderSteps()).toThrow(/cycle/)
   })
 })
 
@@ -110,21 +107,21 @@ describe('agent-common — descendants', () => {
   ])
 
   test('a step and everything that transitively waits on it, in order', () => {
-    expect(pipelineDescendants(graph, 'b')).toEqual(['b', 'd'])
-    expect(pipelineDescendants(graph, 'a')).toEqual(['a', 'b', 'c', 'd'])
+    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(pipelineDescendants(graph, 'b')).not.toContain('aside')
+    expect(makePipelineSpecModel(graph).descendants('b')).not.toContain('aside')
   })
 
   test('refuses a step the spec does not declare', () => {
-    expect(() => pipelineDescendants(graph, 'ghost')).toThrow(/pipeline-step/)
+    expect(() => makePipelineSpecModel(graph).descendants('ghost')).toThrow(/pipeline-step/)
   })
 
   test('pipelineStep answers null rather than throwing', () => {
-    expect(pipelineStep(graph, 'ghost')).toBeNull()
-    expect(pipelineStep(graph, 'a')?.step).toBe('a')
+    expect(makePipelineSpecModel(graph).stepOf('ghost')).toBeNull()
+    expect(makePipelineSpecModel(graph).stepOf('a')?.step).toBe('a')
   })
 })
 

package/tests/results.spec.ts

@@ -1,8 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import {
-  CumulativeFactKind, CumulativeResultSource, RESULTS_EVERY_STEP,
-  compareResultOrder, factKey, mergeResultsSpecs, pipelineAncestors, pipelineAncestry,
-  pipelineDescendants, renderResultEntry, renderResultSummary, resultLabel,
+  CumulativeFactKind, CumulativeResultSource, RESULTS_EVERY_STEP, cumulativeResultsHelper, makePipelineSpecModel,
 } from '../src/index.js'
 import type { CumulativeResultFact, PipelineSpec, RenderableResultEntry } from '../src/index.js'
 
@@ -41,14 +39,14 @@ const entry = (patch: Partial<RenderableResultEntry> = {}): RenderableResultEntr
 
 describe('agent-common — pipeline ancestry', () => {
   test('names every transitive predecessor in topological order, never the step itself', () => {
-    expect(pipelineAncestors(diamond, 'join')).toEqual(['root', 'left', 'right', 'deeper'])
-    expect(pipelineAncestors(diamond, 'root')).toEqual([])
+    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(pipelineDescendants(diamond, 'root')).toContain('root')
+    expect(makePipelineSpecModel(diamond).descendants('root')).toContain('root')
   })
 
   test('carries the SHORTEST distance, so a direct predecessor is depth 1', () => {
-    expect(pipelineAncestry(diamond, 'join')).toEqual([
+    expect(makePipelineSpecModel(diamond).ancestry('join')).toEqual([
       { step: 'root', depth: 2 },
       { step: 'left', depth: 1 },
       { step: 'right', depth: 2 },
@@ -57,14 +55,14 @@ describe('agent-common — pipeline ancestry', () => {
   })
 
   test('refuses a step the spec does not declare', () => {
-    expect(() => pipelineAncestors(diamond, 'ghost')).toThrow(/pipeline-step/)
+    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 = renderResultEntry(entry())
-    const two = renderResultEntry(entry({ facts: [file, create, user] }))
+    const one = cumulativeResultsHelper.renderResultEntry(entry())
+    const two = cumulativeResultsHelper.renderResultEntry(entry({ facts: [file, create, user] }))
 
     expect(two).toEqual(one)
     expect(one.full).toBe([
@@ -76,7 +74,7 @@ describe('agent-common — rendering an entry', () => {
   })
 
   test('the names-only form lists names by kind and says it is names only', () => {
-    expect(renderResultEntry(entry()).compact).toBe([
+    expect(cumulativeResultsHelper.renderResultEntry(entry()).compact).toBe([
       '### types (names only)',
       '- endpoint: `user.create`',
       '- type: `User`',
@@ -85,7 +83,7 @@ describe('agent-common — rendering an entry', () => {
   })
 
   test('over its cap it drops whole facts, never part of one, and says how many', () => {
-    const { full } = renderResultEntry(entry(), { maxChars: 200 })
+    const { full } = cumulativeResultsHelper.renderResultEntry(entry(), { maxChars: 200 })
 
     expect(full.length).toBeLessThanOrEqual(200)
     expect(full).toContain('- endpoint `user.create`')
@@ -94,8 +92,8 @@ describe('agent-common — rendering an entry', () => {
   })
 
   test('a summary is always labelled unverified, and a summary alone heads the entry so', () => {
-    const withFacts = renderResultEntry(entry({ summary: 'Chose soft deletes.' })).full
-    const alone = renderResultEntry(entry({
+    const withFacts = cumulativeResultsHelper.renderResultEntry(entry({ summary: 'Chose soft deletes.' })).full
+    const alone = cumulativeResultsHelper.renderResultEntry(entry({
       facts: [], summary: 'Chose soft deletes.', source: CumulativeResultSource.Summarized,
     })).full
 
@@ -104,37 +102,37 @@ describe('agent-common — rendering an entry', () => {
   })
 
   test('a partial entry says the step failed, and an empty ordinary entry renders nothing', () => {
-    expect(renderResultEntry(entry({ partial: true })).full.split('\n')[0])
+    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(renderResultEntry(entry({ facts: [] }))).toEqual({ full: '', compact: '' })
+    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(compareResultOrder)).toEqual([[0], [1], [3, 1], [3, 2], [3], [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(resultLabel('r', 'r', 'types')).toBe('types')
-    expect(resultLabel('r', 'r/design', 'screens')).toBe('design/screens')
-    expect(resultLabel('r', 'r/design/deep', 'x')).toBe('design/deep/x')
+    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(factKey(user)).toBe(factKey({ ...user, signature: 'other' }))
-    expect(factKey(user)).not.toBe(factKey({ ...user, specifier: '@app/other' }))
+    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(renderResultSummary({ summary: '  two\nlines  ' })).toBe('two lines')
-    expect(renderResultSummary({ b: ['x', 'y'], a: 1 })).toBe('a: 1; b: x, y')
-    expect(renderResultSummary({ summary: 'word '.repeat(100) }, 40).length).toBeLessThanOrEqual(40)
+    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 = mergeResultsSpecs(
+    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 } } },

package/build/flows.d.ts

@@ -1,21 +0,0 @@
-import type { ShallowFlow } from '@owlmeans/flow';
-/**
- * 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 a plugin reading `onFinish` can say where a run ended.
- * `Fail` is reachable from every working step and is TERMINAL — see the note on that step.
- *
- * `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 declare const agentRunFlow: ShallowFlow;
-/** Every flow this package declares, for a provider to serve. */
-export declare const agentFlows: ShallowFlow[];
-//# sourceMappingURL=flows.d.ts.map

package/build/flows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flows.d.ts","sourceRoot":"","sources":["../src/flows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAGjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,EAAE,WA0F1B,CAAA;AAED,iEAAiE;AACjE,eAAO,MAAM,UAAU,EAAE,WAAW,EAAmB,CAAA"}

package/build/flows.js

@@ -1,105 +0,0 @@
-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 a plugin reading `onFinish` can say where a run ended.
- * `Fail` is reachable from every working step and is TERMINAL — see the note on that step.
- *
- * `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 = {
-    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,
-            // Terminal. Nothing resumes a ReAct run — its tool results are side effects already applied
-            // to the world, so re-entering it re-applies them. Resumable work is a pipeline.
-            transitions: {},
-        },
-    },
-};
-/** Every flow this package declares, for a provider to serve. */
-export const agentFlows = [agentRunFlow];
-//# sourceMappingURL=flows.js.map

package/build/flows.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flows.js","sourceRoot":"","sources":["../src/flows.ts"],"names":[],"mappings":"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"}