@owlmeans/agent 0.1.18-rc.50 → 0.1.18-rc.52

package/README.md

@@ -84,7 +84,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.52
+npx @owlmeans/agent-skills@^0.1.18-rc.54
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/agent",
-  "version": "0.1.18-rc.50",
-  "generatedAt": "2026-10-08T21:27:54.306Z",
+  "version": "0.1.18-rc.52",
+  "generatedAt": "2026-10-15T10:20:01.303Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/agent/SKILL.md

@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/agent
 
 **Layer:** Cross-cutting domain
-**Install:** `"@owlmeans/agent": "^0.1.18-rc.50"` in `dependencies`, plus the `@langchain/core` and
+**Install:** `"@owlmeans/agent": "^0.1.18-rc.52"` in `dependencies`, plus the `@langchain/core` and
 `@langchain/langgraph` **peers**
 
 The agent runtime. Contracts live in `@owlmeans/agent-common`.

package/build/pipeline/types.d.ts

@@ -0,0 +1,328 @@
+import type { BaseCheckpointSaver } from '@langchain/langgraph';
+import type { CumulativeResultEntry, CumulativeResultFact, PipelineProgress, PipelineRun, PipelineRunInquiry, PipelineRunStatus, PipelineSpec, PipelineState, ResultFactQuery, ResultViewMode } from '@owlmeans/agent-common';
+import type { CumulativeResults, Inquiry, InquiryAnswer } from '@owlmeans/llm-common';
+import type { PipelineRunStore } from '../stores/types.js';
+/**
+ * What a step is handed while it runs.
+ *
+ * Everything on it is runtime — none of it is serialized, and `deps` in particular is the bag of
+ * collaborators (a file helper, an execution, a service) that make the step able to do anything at
+ * all. Keeping them here rather than in the state is the whole reason a pipeline state can stay
+ * small enough to write at every step boundary.
+ */
+export interface PipelineRunContext<S extends PipelineState, C> {
+    runId: string;
+    step: string;
+    spec: PipelineSpec;
+    /** Whatever the caller passed to `invoke`/`resume`. NEVER serialized. */
+    deps: C;
+    /** The subject the run belongs to — carried so a composed sub-pipeline inherits it. */
+    scope: string;
+    entityId?: string;
+    /** Steps already behind this one, including those a resume inherited. */
+    completed: readonly string[];
+    /** Aborted when the caller's signal aborts, and when the run's budget runs out. */
+    signal: AbortSignal;
+    /**
+     * Persist a patch NOW, before the step returns.
+     *
+     * The unit of replay is a step, so a step that does N undoable things in a loop has to be able to
+     * say how many it has done — otherwise a resume repeats them. Every `mark` is a row write, so
+     * mark a cursor, never a payload.
+     */
+    mark: (patch: Partial<S>) => Promise<void>;
+    /** Progress, not state. Reaches `onProgress` and the run row's `note`; never replayed. */
+    report: (note: string) => void;
+    /**
+     * The run's budget is spent.
+     *
+     * Cooperative: a step that can stop cleanly should finish the unit it is on and return. The
+     * runner then ends the run `Aborted` with `pending` naming what is left, and a later resume
+     * continues from there.
+     */
+    expired: () => boolean;
+    /** What is left of the run's budget, or `undefined` when it has none. */
+    remainingMs: () => number | undefined;
+    /**
+     * Put a question to a person and wait for the answer.
+     *
+     * Three outcomes, in this order. An answer already in the state — which is what a resume carries
+     * — comes straight back. A live channel that answers has its answer RECORDED in the state before
+     * it is returned, so the same question is never asked twice. Otherwise the run stops `Waiting`
+     * with the inquiry on its row and this call never returns: it throws the runner's own stop
+     * signal, which is not a failure and must not be caught by the step.
+     *
+     * What the step reads is the WHOLE answer; only the copy kept in the state is cut, because a
+     * state is scalars and keys and an answer's prose belongs wherever the pipeline keeps documents.
+     *
+     * `Inquiry.id` is the ONLY thing an answer is matched by, so it must be DERIVED from the step and
+     * the thing being decided — never minted per call. An id generated afresh on every entry can
+     * never match what the state holds, so the run re-asks and parks again forever.
+     */
+    ask: (inquiry: Inquiry) => Promise<InquiryAnswer>;
+    /**
+     * What the earlier steps produced, cut for this step — present only when a pipeline plugin
+     * supplies it (`cumulativeResultsPlugin`). A pipeline that seats no such plugin never has the key.
+     *
+     * Hand `results.view` to the step's execution (`ExecutionService.withResults`) and every model
+     * built from it composes the view; call `results.record` with what the step wrote so the next
+     * steps are told about it.
+     */
+    results?: StepResults;
+}
+/** What a step tells the results plugin about itself. Every call adds to the last. */
+export interface ResultRecordInput {
+    /** Files the step wrote or rewrote, relative to the project root. */
+    files?: string[];
+    /** Facts the step already knows. Taken as they are, ahead of anything an extractor finds. */
+    facts?: CumulativeResultFact[];
+}
+/** One entry a step can see, and how its view shows it. */
+export interface VisibleResultEntry {
+    entry: CumulativeResultEntry;
+    mode: ResultViewMode;
+    /** Left out of the prompt for BUDGET — named in `view.omitted` — rather than by declaration. */
+    dropped?: boolean;
+}
+/**
+ * The results surface of ONE step: the view to put in its prompt, a query over the facts behind
+ * that view for code that wants them, and the way to report what the step produced.
+ */
+export interface StepResults {
+    /** The ledger the step's entries belong to. */
+    ledger: string;
+    /** Where the step sits in the ledger — the order key a run composed under it extends. */
+    order: readonly number[];
+    /** Serializable and frozen; `ExecutionService.withResults(exec, results.view)`. */
+    view: CumulativeResults;
+    /** Every entry visible to the step, oldest first, with how the view shows it. */
+    entries: () => readonly VisibleResultEntry[];
+    /**
+     * Facts visible to the step, narrowed by kind, name and producing step — including those the
+     * PROMPT left out for space or by declaration: a budget is about what a model reads, and code
+     * asking for a fact is not a model reading a prompt.
+     */
+    facts: (query?: ResultFactQuery) => CumulativeResultFact[];
+    /** Report files touched and facts known. Read once, when the step finishes. */
+    record: (input: ResultRecordInput) => void;
+}
+/**
+ * The composing step of a parent pipeline, as a run composed under it (`asStep`) sees it —
+ * read-only by construction: a composed run may learn where it sits, never write its parent.
+ */
+export interface PipelineParentRef {
+    pipeline: string;
+    runId: string;
+    step: string;
+    /** The parent step's results surface, when its pipeline seats a results plugin. */
+    results?: StepResults;
+}
+/**
+ * How a run entered the runner: a first run, a run carried on from where its row stopped (an
+ * `invoke` on an unfinished row, or any `resume`), or an unfinished row discarded on request.
+ */
+export type PipelineEnterMode = 'fresh' | 'continue' | 'restart';
+export interface PipelineEnterEvent<S extends PipelineState, C> {
+    spec: PipelineSpec;
+    runId: string;
+    scope: string;
+    entityId?: string;
+    deps: C;
+    mode: PipelineEnterMode;
+    /** Steps this execution inherits as complete, in order. None of them will run or pass. */
+    inherited: readonly string[];
+    /** The state the run starts from — restored from its row, with the seed or patch merged. */
+    state: Readonly<S>;
+    /** Present when the run is a step of another pipeline. */
+    parent?: PipelineParentRef;
+}
+export interface PipelineStepEvent<S extends PipelineState, C> {
+    step: string;
+    ctx: PipelineRunContext<S, C>;
+    /** The live state. Read it; a plugin never writes it. */
+    state: Readonly<S>;
+}
+export interface PipelineAfterStepEvent<S extends PipelineState, C> extends PipelineStepEvent<S, C> {
+    /** What the step returned, already merged into `state`. */
+    patch: Partial<S>;
+}
+export interface PipelinePassStepEvent<S extends PipelineState, C> extends PipelineStepEvent<S, C> {
+    /** `skipped` — its guard answered true; `failed` — it is `optional`, failed, and the run goes on. */
+    reason: 'skipped' | 'failed';
+    error?: Error;
+}
+export interface PipelineExitEvent<S extends PipelineState, C> {
+    spec: PipelineSpec;
+    runId: string;
+    deps: C;
+    result: PipelineResult<S>;
+}
+/** What `beforeStep` may hand the step. The first plugin to offer `results` owns them. */
+export interface PipelineStepContribution {
+    results?: StepResults;
+}
+/**
+ * An optional capability of a pipeline run, seated by `alias` and run by ascending `order`.
+ *
+ * A plugin WATCHES a run: it never writes the pipeline's state — whatever it keeps, it keeps in a
+ * store of its own — and it never decides where a run stands, which the row alone does. Every hook
+ * is wrapped: a plugin that throws is logged and the run goes on, because losing an enhancement
+ * costs what it adds and never the work. The one exception is an error `PipelineOptions.fatal`
+ * calls fatal, which takes the exact path a fatal step error takes — the row written `Failed`
+ * first, then the error rethrown.
+ *
+ * - `enter` — once per `invoke`/`resume`, before the first step, with how the run entered.
+ * - `beforeStep` — once the runner has decided the step will RUN, before it runs.
+ * - `afterStep` — after the step's patch is merged into the state and BEFORE the row commit that
+ *   marks the step complete, so what a plugin persists lands before the step is durably done.
+ * - `passStep` — a step skipped by its guard, or an optional step that failed.
+ * - `exit` — once, at the end, with the result the caller is about to receive.
+ */
+export interface PipelinePlugin<S extends PipelineState, C> {
+    alias: string;
+    /** Lower runs first. Defaults to 50. */
+    order?: number;
+    enter?: (event: PipelineEnterEvent<S, C>) => Promise<void> | void;
+    beforeStep?: (event: PipelineStepEvent<S, C>) => Promise<PipelineStepContribution | void> | PipelineStepContribution | void;
+    afterStep?: (event: PipelineAfterStepEvent<S, C>) => Promise<void> | void;
+    passStep?: (event: PipelinePassStepEvent<S, C>) => Promise<void> | void;
+    exit?: (event: PipelineExitEvent<S, C>) => Promise<void> | void;
+}
+/**
+ * How a pipeline puts a question to a person.
+ *
+ * Absent altogether means no channel at all: a step that asks parks the run at once. That is the
+ * safe default — a run given no way to ask must never invent one.
+ */
+export interface PipelineInquiryOptions<S extends PipelineState, C> {
+    /**
+     * Answer live, or `null` to say nobody is there — which parks the run.
+     *
+     * A THROW is not a park: it escapes and fails the step as an ordinary outcome, because an error
+     * from the channel says the asking failed, not that the answer is no.
+     */
+    ask?: (inquiry: Inquiry, ctx: PipelineRunContext<S, C>) => Promise<InquiryAnswer | null>;
+    /** Where answers live in the state. Defaults to `INQUIRY_ANSWERS_KEY`. */
+    answersKey?: string;
+    /** Ceiling on ONE answer. Defaults to `DEFAULT_INQUIRY_ANSWER_CHARS`. */
+    maxAnswerChars?: number;
+}
+export interface PipelineStep<S extends PipelineState, C> {
+    step: string;
+    /**
+     * Answered on EVERY entry — a first run, a resume, a replay — and `true` makes the step a no-op.
+     *
+     * This is what makes a resume correct, and it is deliberately not delegated to the graph engine:
+     * a guard reads the durable marker the step itself wrote, so it is right whether or not anything
+     * replayed, whether or not a checkpoint survived, and whether or not the step list has since
+     * been reordered.
+     */
+    skipWhen?: (state: Readonly<S>, ctx: PipelineRunContext<S, C>) => Promise<boolean> | boolean;
+    /** Returns the patch to merge into the state. `void` means "nothing to record". */
+    run: (state: Readonly<S>, ctx: PipelineRunContext<S, C>) => Promise<Partial<S> | void>;
+}
+export interface PipelineOptions<S extends PipelineState, C> {
+    steps: PipelineStep<S, C>[];
+    /** Where the run row lives. Absent ⇒ the run is not resumable and nothing is persisted. */
+    runs?: PipelineRunStore;
+    /**
+     * LangGraph's own persistence. Optional by contract: the run row is the authority, so a missing
+     * or expired checkpoint costs a replay, never a correct answer.
+     */
+    checkpointer?: BaseCheckpointSaver;
+    /**
+     * Errors that must escape rather than become a `Failed` result — an exhausted budget, a refusal.
+     * The row is written `Failed` first, then the error is rethrown.
+     */
+    fatal?: (e: unknown) => boolean;
+    maxStateChars?: number;
+    /** How `ctx.ask` reaches a person. Absent ⇒ every question parks the run. */
+    inquiry?: PipelineInquiryOptions<S, C>;
+    onProgress?: (progress: PipelineProgress) => void;
+    /** One line per step boundary. The only place a runner says anything. */
+    trace?: (line: string) => void;
+    /**
+     * Optional capabilities of every run — seated by alias, run by ascending `order`. None seated,
+     * the runner behaves exactly as if the seam did not exist: no hook is awaited, and a step's
+     * context carries no `results`.
+     */
+    plugins?: PipelinePlugin<S, C>[];
+}
+export interface PipelineResult<S extends PipelineState> {
+    runId: string;
+    status: PipelineRunStatus;
+    state: S;
+    completed: string[];
+    pending: string[];
+    warnings: string[];
+    failedAt?: string;
+    error?: Error;
+    note?: string;
+    /** What a `Waiting` run stopped on. Present only with that status. */
+    inquiry?: PipelineRunInquiry;
+}
+export interface PipelineInvokeArgs<C> {
+    runId: string;
+    deps: C;
+    /** The subject the run belongs to — an application with projects passes the project id. */
+    scope: string;
+    entityId?: string;
+    /** Recorded so a resume can re-take the same lock. */
+    lockTask?: string;
+    budgetMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: PipelineProgress) => void;
+    /**
+     * Discard an unfinished run under this id and start over.
+     *
+     * Without it, invoking a runId whose row is `Running`, `Failed` or `Aborted` CONTINUES it — which
+     * is what makes a handler that is simply called again pick up where it stopped instead of paying
+     * for the work twice. A `Done` row always starts a fresh run.
+     */
+    restart?: boolean;
+    /**
+     * The composing step, when this run is a step of another pipeline. Set by `asStep`; handed to
+     * the plugins' `enter`, and never persisted.
+     */
+    parent?: PipelineParentRef;
+}
+export interface PipelineResumeArgs<C> {
+    deps: C;
+    /** Re-enter this step and everything that waits on it. Defaults to whatever is not complete. */
+    from?: string;
+    /** Required to re-enter a completed `nonIdempotent` step. */
+    force?: boolean;
+    /** Merged into the restored state before the first step runs. */
+    patch?: Record<string, unknown>;
+    /**
+     * Answers to questions the run parked on, keyed by inquiry id.
+     *
+     * MERGED into the state's answers rather than assigned over them, and merged last — after
+     * `patch` — so an answer given earlier is never dropped by a resume that carries a newer one.
+     */
+    answers?: Record<string, InquiryAnswer>;
+    budgetMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: PipelineProgress) => void;
+}
+/**
+ * How a pipeline becomes one step of another.
+ *
+ * The child keeps its own run row (`<parentRunId>/<step>`), so a parent resumed at the composing
+ * step resumes the child at the child's own failed step rather than re-running all of it.
+ */
+export interface PipelineStepMapping<S extends PipelineState, PS extends PipelineState> {
+    input: (parent: Readonly<PS>) => Partial<S>;
+    output: (child: Readonly<S>, parent: Readonly<PS>) => Partial<PS>;
+    /** Called when the child ends `Failed`. Return `true` to swallow it into the parent's warnings. */
+    tolerate?: (result: PipelineResult<S>) => boolean;
+}
+export interface PipelineModel<S extends PipelineState, C> {
+    spec: () => PipelineSpec;
+    invoke: (seed: Partial<S>, args: PipelineInvokeArgs<C>) => Promise<PipelineResult<S>>;
+    resume: (runId: string, args: PipelineResumeArgs<C>) => Promise<PipelineResult<S>>;
+    /** The run row as stored. `null` with no store bound, or for an unknown run. */
+    snapshot: (runId: string) => Promise<PipelineRun | null>;
+    asStep: <PS extends PipelineState>(step: string, mapping: PipelineStepMapping<S, PS>) => PipelineStep<PS, C>;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/pipeline/types.d.ts.map

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

package/build/pipeline/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/pipeline/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/pipeline/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@owlmeans/agent",
-  "version": "0.1.18-rc.50",
+  "version": "0.1.18-rc.52",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -69,11 +69,11 @@
   },
   "dependencies": {
     "@owlmeans/agent-common": "^0.1.18-rc.49",
-    "@owlmeans/basic-ids": "^0.1.18-rc.39",
+    "@owlmeans/basic-ids": "^0.1.18-rc.40",
     "@owlmeans/context": "^0.1.18-rc.34",
     "@owlmeans/error": "^0.1.18-rc.38",
     "@owlmeans/flow": "^0.1.18-rc.45",
-    "@owlmeans/llm": "^0.1.18-rc.47",
+    "@owlmeans/llm": "^0.1.18-rc.50",
     "@owlmeans/llm-common": "^0.1.18-rc.39",
     "@owlmeans/log": "^0.1.18-rc.3",
     "ajv": "^8.20.0"