agentfootprint 13.0.0 → 14.0.0

package/dist/esm/events/payloads/agent.d.ts

@@ -0,0 +1,241 @@
+import type { LLMMessage, TurnEndScripts } from './dependencyTypes.js';
+import type { AnswerAssessmentPayload, AnswerNegativesPayload } from './answer.js';
+import type { PeriodPayload } from './toolEffects.js';
+import type { CoverageItemPayload, InProgressItemPayload } from './toolSemantics.js';
+export interface AgentTurnStartPayload {
+    readonly turnIndex: number;
+    readonly userPrompt: string;
+}
+export interface AgentTurnEndPayload {
+    readonly turnIndex: number;
+    readonly finalContent: string;
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly iterationCount: number;
+    readonly durationMs: number;
+    /**
+     * Why the loop stopped before the model said it was done (9.56.0) — present
+     * ONLY on a turn a limit cut short, absent on every normal finish.
+     *
+     * It rides `turn_end` because that is the event a consumer already reads to
+     * render an outcome: the moment the answer exists. Reading `finalContent`
+     * without it, a dashboard cannot tell a finished answer from the fragment a
+     * loop stopped in the middle of — which is exactly how a half-sentence gets
+     * shown to a person under a green tick.
+     *
+     * `wrappedUp` says which of the two this is. `true` = the run spent one more
+     * call with the tools withheld and `finalContent` is that summary; absent =
+     * the turn ended on whatever the last call produced. Mirrors the committed
+     * `stoppedEarly` record (`agent.stoppedEarly()`), never a second source of
+     * it.
+     */
+    readonly stoppedEarly?: {
+        readonly reason: 'max-iterations' | 'cost-budget';
+        readonly iteration: number;
+        readonly pendingToolCalls: number;
+        readonly wrappedUp?: true;
+    };
+    /**
+     * The limits of a TYPED answer, as data — present ONLY when the agent has an
+     * output schema and `.limitsTravelWithTheAnswer()`, and the run's tools
+     * declared something; absent on every other turn.
+     *
+     * A prose answer carries its limits as a block appended to `finalContent`.
+     * A typed answer cannot: it is JSON, and JSON followed by prose is not JSON.
+     * So `finalContent` stays the model's answer and the same limits ride here —
+     * what the tools `checked`, did not check and can never cover, folded across
+     * the run (duplicates said once, every entry kept). Mirrors the committed
+     * `answerCoverage` record (`agent.answerCoverage()`), never a second source
+     * of it.
+     */
+    readonly answerCoverage?: {
+        readonly checked: readonly CoverageItemPayload[];
+        readonly notChecked: readonly CoverageItemPayload[];
+        readonly cannotCover: readonly CoverageItemPayload[];
+        /**
+         * The periods the calls' results declared (honesty step 7b) — one per
+         * declaring call, as declared; present only when one did. The data twin of
+         * a prose answer's `Period:` lines.
+         */
+        readonly periods?: readonly (PeriodPayload & {
+            readonly toolName: string;
+            readonly toolCallId?: string;
+        })[];
+        /**
+         * What the calls' reads found still running — its outcome not known yet —
+         * one entry per declaring call, as declared; present only when one did.
+         * The data twin of a prose answer's "In progress" lines.
+         */
+        readonly inProgress?: readonly {
+            readonly toolName: string;
+            readonly toolCallId?: string;
+            readonly items: readonly InProgressItemPayload[];
+        }[];
+        /**
+         * The values a tool's `assume` rule filled this turn (the inputs layer,
+         * honesty layer 2) — the SAME rows, read the same way, that the prose
+         * answer's "Assumed" block prints (`arguments/serve.ts` ·
+         * `assumedLinesFor`): one entry per distinct (tool, argument, value), a
+         * row a before-tool rewrite superseded left out. `value` is the tool's
+         * own argument view; `'REDACTED'` with `hidden` when that view hides it.
+         * Present only when a value was assumed.
+         */
+        readonly assumed?: readonly {
+            readonly toolName: string;
+            readonly argument: string;
+            readonly value: string;
+            readonly hidden: boolean;
+        }[];
+    };
+    /**
+     * The answer's standing, as data — present ONLY on an agent with
+     * `.answerLayer()` (honesty layer 4), and then on every turn that ends in
+     * an answer. The same projection `agentfootprint.answer.assessed` carries
+     * ({@link AnswerAssessmentPayload}): the value, its rendering, the reason
+     * kinds and the checks that ran; never a value or a quote. It rides
+     * `turn_end` because that is the event a consumer already reads to render
+     * an outcome — including a composition that mounts the agent, whose
+     * dispatcher carries the agent's `turn_end` but not the `answer.*` domain.
+     */
+    readonly answerAssessment?: AnswerAssessmentPayload;
+    /**
+     * The app's words the appended standing line named calls in — registered
+     * tool name → the tool's declared `displayName`. Present ONLY when the line
+     * (`.answerLayer({ standingLine: true })`) named a reason's calls by a
+     * declared name, so every other turn emits the exact payload it always did.
+     * The words are the app's own, already in `finalContent`; the record keeps
+     * them so a reader rebuilds the very line from the record.
+     */
+    readonly standingLineNames?: Readonly<Record<string, string>>;
+    /** Runtime-composed typed negatives, with verification and delivery kept separate. */
+    readonly answerNegatives?: AnswerNegativesPayload;
+    /**
+     * The scripts the library attached to the answer — present ONLY under
+     * `.scriptTravelsWithTheAnswer()`, on every answer. Each `shown` entry is
+     * the program a call SUBMITTED to a declared code-running tool, read from
+     * the run record (never retyped by the model), with the call's label read
+     * from its execution record: `exitCode` only when the runner supplied one,
+     * `truncated` when the text is cut at `maxBytes`. `omitted` counts the
+     * calls not attached (the cap, a program over the bound, a call past the
+     * per-turn rows). A prose answer also carries them as text after its `---`
+     * separator; a typed answer carries them here only. `text` is a
+     * model-written string: under any redaction policy it is served as the
+     * placeholder, and the label and the counts survive.
+     */
+    readonly scripts?: TurnEndScripts;
+    /**
+     * The answer was REFUSED — present ONLY then. Under the evidence gate's
+     * `'rails'` posture (`.namesAndNumbersFromEvidence()`), an answer stating
+     * values no tool result carried is not delivered: `run()` raises
+     * `UnsupportedValuesError`. `finalContent` stays for the record (the answer
+     * account explains the refusal from it), but it is NOT the agent's answer —
+     * a consumer rendering an outcome shows the refusal, never this text.
+     */
+    readonly refused?: {
+        readonly by: 'evidence-rails';
+    };
+}
+/**
+ * A turn's budget ran out while the model was still working (9.56.0).
+ *
+ * Fires ONCE per turn, from the Route decider, at the boundary that refused to
+ * run the tool calls the model just asked for — the same moment
+ * `cost.limit_hit { kind: 'max_iterations' }` fires, and beside it rather than
+ * instead of it: that event reports a LIMIT being crossed, this one reports
+ * what the run then DID about it.
+ *
+ * `action` is the whole point. `'wrapped-up'` means one more call went out with
+ * the tools withheld and its answer is the turn's answer; `'cut-short'` means
+ * the turn ended on whatever text rode the last call — a fragment, mid-task,
+ * more often than not. A consumer that only ever sees `'wrapped-up'` is
+ * looking at a healthy default; one seeing `'cut-short'` is looking at a turn
+ * whose answer nobody should trust as complete.
+ */
+export interface AgentBudgetExhaustedPayload {
+    /** Which budget ran out. Only `'max-iterations'` is ever wrapped up. */
+    readonly reason: 'max-iterations' | 'cost-budget';
+    /** The iteration the budget ran out on. */
+    readonly iteration: number;
+    /**
+     * The budget itself — present ONLY for `'max-iterations'`, where it is
+     * `maxIterations`.
+     *
+     * Absent for `'cost-budget'`, deliberately: the run's committed state carries
+     * the cumulative SPEND, not the cap, and reporting spend as `limit` is the
+     * exact mistake `cost.limit_hit` documents and avoids. The real USD cap rides
+     * that event, emitted the moment the budget was crossed.
+     */
+    readonly limit?: number;
+    /** How many tool calls the model asked for that will never run. */
+    readonly pendingToolCalls: number;
+    /** What the run did about it. */
+    readonly action: 'wrapped-up' | 'cut-short';
+}
+export interface AgentIterationStartPayload {
+    readonly turnIndex: number;
+    readonly iterIndex: number;
+}
+export interface AgentIterationEndPayload {
+    readonly turnIndex: number;
+    readonly iterIndex: number;
+    /**
+     * On the main loop, the calls the turn proposed. On a resume leg (9.113.0),
+     * the brackets THAT leg closed: the paused call plus each sibling the batch
+     * settlement answered — so a batch of three paused on its middle call
+     * reports 2, and the calls before the pause are counted by no
+     * `iteration_end` (their brackets closed on the leg that paused). For the
+     * batch's size, read `tool_start.parallelCount`. See `src/core/README.md` ·
+     * "A batch that pauses settles its un-dispatched siblings".
+     */
+    readonly toolCallCount: number;
+    /** Conversation history (LLM messages) at the END of this
+     *  iteration. Captured by `agent.run()` for fault-tolerant
+     *  resume — `RunCheckpointError.checkpoint` snapshots this so
+     *  `agent.resumeOnError(...)` can replay from the last good
+     *  iteration. Optional for back-compat with v2.x recorders that
+     *  subscribed without expecting this field. Typed as the messages it
+     *  holds, so its field names and roles are the library's own words on a
+     *  redacted record (`redaction/knownStrings.ts`). */
+    readonly history?: ReadonlyArray<LLMMessage>;
+}
+/**
+ * The `route_decided` rationales that are FIXED sentences — the library's own
+ * words, so a redacted record keeps them (`redaction/knownStrings.ts`). A
+ * rationale composed per turn (a count of calls, a skill's name) is a free
+ * string there, kept out under a policy like any other.
+ */
+export type FixedRouteRationale = 'LLM produced no tool calls — final answer' | 'maxIterations reached — forcing final' | 'costBudget reached (onExceed: halt) — forcing final' | 'tools are off after the evidence revision (answer validation enforces) — forcing final';
+/**
+ * The `pause.request` reason the library writes when the pause carries none —
+ * the library's own words (`redaction/knownStrings.ts`). A reason the pause
+ * carries is a free string.
+ */
+export type FixedPauseReason = 'stage requested pause';
+export interface AgentRouteDecidedPayload {
+    readonly turnIndex: number;
+    readonly iterIndex: number;
+    /**
+     * The branch the turn took. `'output-retry'` (7.26) appears only on an
+     * agent built with `.outputSchema(parser, { retries })`, and only on a
+     * turn whose answer failed the schema with retries left — the loop is
+     * about to ask again rather than finish. `'step-nudge'` (9.18.0) appears
+     * only on an agent with a stepped skill, and only on a turn whose
+     * would-be-final answer left declared steps unrun with the one teaching
+     * nudge still unspent. `'evidence-recheck'` (9.35.0) appears only on an
+     * agent built with `.namesAndNumbersFromEvidence({ posture: 'guard' |
+     * 'rails' })`, and only on a turn whose would-be-final answer stated values
+     * no tool result carried, with the one revision still unspent. `'wrap-up'`
+     * (9.56.0) appears only on a turn whose `maxIterations` ran out while the
+     * model was still asking for tools, on an agent that did not set
+     * `wrapUpAtMaxIterations: false` — the loop is about to spend one last call
+     * with the tools withheld so the turn ends with a summary.
+     */
+    readonly chosen: 'tool-calls' | 'final' | 'output-retry' | 'step-nudge' | 'evidence-recheck' | 'negative-recheck' | 'wrap-up';
+    readonly rationale?: FixedRouteRationale | (string & Record<never, never>);
+}
+export interface AgentHandoffPayload {
+    readonly fromAgentId: string;
+    readonly toAgentId: string;
+    readonly reason?: string;
+    readonly viaProtocol?: 'native' | 'mcp' | 'http';
+}

package/dist/esm/events/payloads/agent.js

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

package/dist/esm/events/payloads/agent.js.map

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

package/dist/esm/events/payloads/answer.d.ts

@@ -0,0 +1,95 @@
+import type { AssessmentCheck, AssessmentReason, HonestyLayer } from './dependencyTypes.js';
+/**
+ * The answer's standing as data — the SAME projection on
+ * `agentfootprint.answer.assessed` and on `turn_end.answerAssessment`, built
+ * by one function (`assessment/compose.ts` · `assessmentDataOf`) from the one
+ * fold (`assessAnswer`) the answer layer runs at the head of the final
+ * branch. Names, enums and counts only: the value, its rendering, the reason
+ * KINDS and the checks that ran — never a value from the answer, a quote, a
+ * witness pointer or the support's digest (those stay on the committed rows
+ * `agent.assessment()` folds, with their pointers).
+ */
+export interface AnswerAssessmentPayload {
+    /** The value: `known | unrefuted | unknown | not-applicable`. */
+    readonly assessment: 'known' | 'unrefuted' | 'unknown' | 'not-applicable';
+    /** The owner's words for it: known · consistent · not sure · ask · not assessed. */
+    readonly standing: 'known' | 'consistent' | 'not-sure' | 'ask' | 'not-assessed';
+    /** Every reason that fired, by kind, in the fold's order (the ask first, then by layer). */
+    readonly reasons: readonly AssessmentReason[];
+    /** What actually ran this turn, printed as it is — never a fixed list. */
+    readonly checked: readonly {
+        readonly layer: HonestyLayer;
+        readonly check: AssessmentCheck;
+        readonly ran: number;
+        readonly of: number;
+    }[];
+}
+/**
+ * The answer layer assessed the turn's answer (honesty layer 4,
+ * `.answerLayer()`): ONE event per answer, fired at the head of the final
+ * branch — after the Route decider's checks filed their verdicts and before
+ * the turn's payload is captured. It carries the standing as data
+ * ({@link AnswerAssessmentPayload}) with the conversation turn and the
+ * answer's iteration. The fold it reports reads committed rows only, so the
+ * same recording read afterwards with `assessAnswer` folds the same value
+ * (without app declarations — `assessAnswer(record, declarations)` with
+ * `rowsAt` can say more than the run did).
+ *
+ * Where it reaches, and what it is about:
+ * - the agent's own listeners only — a composition that mounts the agent
+ *   bridges the agent domain, not `answer.*`, so read
+ *   `turn_end.answerAssessment` there;
+ * - the answer the run COMPOSED: under the evidence gate's `rails` posture a
+ *   refused answer is assessed too, and then the run throws (no answer is
+ *   delivered, and `agent.assessment()` returns `undefined`).
+ */
+export interface AnswerAssessedPayload extends AnswerAssessmentPayload {
+    /** `AgentState.turnNumber` — the conversation turn. */
+    readonly turn: number;
+    /** The iteration whose answer was assessed. */
+    readonly iteration: number;
+}
+/** One library-written negative statement, shared by delivery and its event. */
+export interface DeliveredNegative {
+    readonly kind: 'none' | 'not-found' | 'complete' | 'unknown';
+    /** The single public population value derived from admitted searches, never model wording.
+     * Omitted for multiple or unknown subjects; their individual scopes remain in the statement. */
+    readonly about?: string | number;
+    readonly restsOn: readonly string[];
+    readonly statement: string;
+    readonly delivery: 'record-composed';
+    readonly version: string;
+}
+/** Served negative statements. Codes and identities are diagnostics; the statement is library-written. */
+export interface AnswerNegativesPayload {
+    readonly field: string;
+    readonly version: string;
+    readonly delivery: 'as-checked' | 'recorded' | 'fallback';
+    readonly claims: readonly DeliveredNegative[];
+    readonly checks: readonly {
+        readonly id: string;
+        readonly path: string;
+        readonly index: number;
+        readonly kind: 'none' | 'not-found' | 'complete' | 'unknown';
+        /** Audit-only: none/not-found was normalized over an explicitly declared absence. */
+        readonly notes?: readonly 'absence-kind-normalized'[];
+        readonly code: string;
+        readonly disposition: 'checked-fail' | 'not-applicable' | 'unreachable';
+        readonly tools: readonly string[];
+        readonly results: readonly string[];
+        /** On a `'stale-turn'` check: the turn the cited result was read on, and when
+         *  the read ran (the library's own clock), when it was recorded. */
+        readonly staleSince?: {
+            readonly turn: number;
+            readonly readAt?: string;
+        };
+    }[];
+    readonly coverage: readonly {
+        readonly tool: string;
+        readonly checked: number;
+    }[];
+    readonly actions: readonly {
+        readonly tool: string;
+        readonly outcome: 'ok' | 'error' | 'not-run';
+    }[];
+}

package/dist/esm/events/payloads/answer.js

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

package/dist/esm/events/payloads/answer.js.map

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

package/dist/esm/events/payloads/artifacts.d.ts

@@ -0,0 +1,139 @@
+import type { ArtifactOp, ArtifactOrigin, ArtifactRefusalReason, ArtifactSweepReason, DatasetTimeAxis } from './dependencyTypes.js';
+/** A payload was checked in and the store minted its claim ticket — by a
+ *  tool (`tool` names it), or by no tool at all (see {@link tool}). */
+export interface ArtifactMintedPayload {
+    readonly ref: string;
+    /** Consumer vocabulary: 'dataset/rows', 'chart/spec', … */
+    readonly kind: string;
+    readonly mediaType: string;
+    readonly bytes: number;
+    readonly label?: string;
+    /** `sha-256:<hex>` when the put asked for one. Metadata, never the key. */
+    readonly digest?: string;
+    /** Unix ms when the ref stops resolving — stated at mint, never sprung. */
+    readonly expiresAt?: number;
+    /** The join to the trace: the run and tool call that minted it. */
+    readonly origin?: ArtifactOrigin;
+    /** Derivation facts — validated at mint, so they cannot dangle at birth. */
+    readonly parentRefs?: readonly string[];
+    /** The rows' declared time axis — validated at mint (see `ArtifactMeta.timeAxis`). */
+    readonly timeAxis?: DatasetTimeAxis;
+    /** The tool whose execute minted it. ABSENT when no tool did — the run's own
+     *  recording (9.26.0, the `recordings` dial) or a host filing for its turn
+     *  through `HostReply.turnArtifacts`; the event's `meta.sessionId` then names
+     *  the session the host filed for. Typed as always-present until now, and
+     *  already absent at run time since 9.26.0 — the 9.23.0 `resolved` /
+     *  `refused` precedent. Naming a phantom tool would be an actor a dashboard
+     *  groups by that does not exist. */
+    readonly tool?: string;
+}
+/** A ref was redeemed — described (`head`) or read (`get`) — under scope. */
+export interface ArtifactResolvedPayload {
+    readonly ref: string;
+    /** `head` is the render-by-ref decision; `get` pays for the payload. */
+    readonly via: 'head' | 'get';
+    readonly kind: string;
+    readonly bytes: number;
+    /** The tool that redeemed it. ABSENT when the redemption came through the
+     *  hosting door instead of a tool (9.23.0) — a screen resolving
+     *  `artifact-head` / `artifact-get` over the wire, under the requesting
+     *  session's identity. Stamping a phantom tool name there would be a
+     *  dashboard grouping by an actor that does not exist. */
+    readonly tool?: string;
+}
+/** An artifact left the store without its owner asking — the calendar (ttl)
+ *  or a budget (max-bytes / max-count). Reported by the put that swept it. */
+export interface ArtifactExpiredPayload {
+    readonly ref: string;
+    /** One vocabulary, defined in `artifacts/` and imported here — the
+     *  PermissionCapability lesson: two copies of one union can drift. */
+    readonly reason: ArtifactSweepReason;
+    readonly kind: string;
+    readonly bytes: number;
+    /** The tool whose put discovered/forced the sweep. ABSENT when the put was
+     *  not a tool's — the run's own recording, or a host filing for its turn
+     *  (the {@link ArtifactMintedPayload.tool} rule). */
+    readonly tool?: string;
+}
+/** An artifact verb refused — or answered "no data" — and said why. `no-store`
+ *  is the fail-closed capability teaching how to attach a store;
+ *  `missing-or-expired` keeps the API's deliberate ambiguity while the record
+ *  still shows a resolve that found nothing; `digest-mismatch` is integrity
+ *  refusing to deliver corrupt bytes as whole. Since 9.22.0, `op: 'dispatch'`
+ *  is the framework's own door: a tool's declared `wants` argument (or a
+ *  `present` call) that could not be delivered — the tool did not run and the
+ *  model read a teaching refusal listing what CAN resolve
+ *  (`kind-mismatch` names a ref that resolved to the wrong kind). */
+export interface ArtifactRefusedPayload {
+    readonly op: ArtifactOp;
+    readonly reason: ArtifactRefusalReason;
+    readonly ref?: string;
+    /** The refusal sentence, when one was thrown. */
+    readonly detail?: string;
+    /** The tool whose call was refused. ABSENT when the refusal answered the
+     *  hosting door instead of a tool (9.23.0) — a wire resolution that found
+     *  nothing (`missing-or-expired`: the one indistinguishable answer for
+     *  missing, expired and another-session's alike) or reached an agent with
+     *  no store (`no-store`). */
+    readonly tool?: string;
+}
+/**
+ * Why a turn's artifact hand-over (`HostReply.turnArtifacts`) did not go
+ * cleanly — one vocabulary, shared by this event and the ingress record's
+ * `turnArtifactsFailure`:
+ *
+ *  - `'hook'`      — the host's hook threw or rejected (and not merely by
+ *                    re-throwing an operation's own failure, which is counted
+ *                    once, as `'operation'`);
+ *  - `'operation'` — a verb started through the hand-over failed, awaited or
+ *                    not: a store refusal, an I/O error;
+ *  - `'timeout'`   — the hook and the operations it started outran the ceiling
+ *                    (`turnArtifactsTimeoutMs`); the binding was revoked and the
+ *                    reply delivered, and what was in flight may still land;
+ *  - `'abort'`     — the request's own signal fired (the caller hung up) before
+ *                    they settled; the same consequences;
+ *  - `'expired'`   — a verb was called after its turn ended and was refused.
+ */
+export type ArtifactHandOverFailureCause = 'hook' | 'operation' | 'timeout' | 'abort' | 'expired';
+/**
+ * A turn's artifact hand-over failed (the host's own filing — a story, the
+ * person's clicks). The reply was delivered regardless: the hand-over never
+ * decides it. Emitted on the serving agent for the session it was produced
+ * for (`meta.sessionId`, and `meta.runId` = the turn's run when it had one).
+ *
+ * Class only, never the message: the error came from the host's own code or
+ * its store, and either may carry anything — META ONLY, like every
+ * `artifacts.*` payload. `errorClass` is routable without parsing prose (the
+ * `tools.session_close_failed` precedent).
+ */
+export interface ArtifactHandOverFailedPayload {
+    readonly cause: ArtifactHandOverFailureCause;
+    /** The verb, for `'operation'` and `'expired'`. */
+    readonly op?: ArtifactOp;
+    /** Constructor name of what was thrown, when it was an `Error`. */
+    readonly errorClass?: string;
+    /** This package's (or the store's) own `code`, when the error carried one. */
+    readonly errorCode?: string;
+}
+/** The model handed an artifact to the screen (9.22.0): `present({ ref, as,
+ *  label? })` resolved under the run's scope. `snapshot` is the description
+ *  the claim ticket carries at speak time — `{ kind, mediaType, bytes,
+ *  label }` — the same snapshot stored INSIDE the tool result so a reloaded
+ *  conversation can render an honest placeholder after the artifact expired.
+ *  `as` is the model's consumer vocabulary ('bar-chart', 'table', …), stored
+ *  as data — the component registry that would validate it is a later phase.
+ *  Meta only, never the payload: the screen redeems the ref itself, under
+ *  its own identity. */
+export interface ArtifactPresentedPayload {
+    readonly ref: string;
+    readonly as: string;
+    readonly snapshot: {
+        readonly kind: string;
+        readonly mediaType: string;
+        readonly bytes: number;
+        readonly label?: string;
+    };
+    /** The presenting call — the join to the trace. */
+    readonly toolCallId: string;
+    readonly iteration: number;
+}

package/dist/esm/events/payloads/artifacts.js

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

package/dist/esm/events/payloads/artifacts.js.map

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

package/dist/esm/events/payloads/consent.d.ts

@@ -0,0 +1,86 @@
+import type { LoopMoment } from './dependencyTypes.js';
+import type { FixedPauseReason } from './agent.js';
+export interface ErrorFatalPayload {
+    readonly error: string;
+    readonly stage: string;
+    readonly scope: string;
+}
+export interface PauseRequestPayload {
+    readonly reason: FixedPauseReason | (string & Record<never, never>);
+    readonly questionPayload: Readonly<Record<string, unknown>>;
+}
+export interface PauseResumePayload {
+    /**
+     * The reply the run resumed with. For the inputs layer's own ask
+     * (`awaitingInput.context.agentfootprint.ask === 'arguments'`) every
+     * answered value reads `'REDACTED'` — the reply's shape (request id, field
+     * ids) travels, the person's values do not, because they fill arguments a
+     * tool's view may hide; the `answered` argument rows carry what each tool's
+     * view allows.
+     */
+    readonly resumeInput: Readonly<Record<string, unknown>>;
+    readonly pausedDurationMs: number;
+    /** The registered component the paused ask nominated to collect its answer
+     *  (9.24.0) — read from the checkpoint's own pause payload, whichever pause
+     *  kind carried it. Absent when the ask was prose-only. */
+    readonly componentId?: string;
+}
+/** A tool declared `checkIn` and it tripped — the run paused to ask a human,
+ *  with the evidence pack riding the ask. Emitted BEFORE the tool executes. */
+export interface CheckInRequestPayload {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly iteration: number;
+    /** The typed ask + evidence pack (`CheckInRequest`). JSON/clone-safe. */
+    readonly request: Readonly<Record<string, unknown>>;
+}
+/** A human answered a pending check-in. Emitted on resume, BEFORE the tool
+ *  runs (approve) or the decline result lands. */
+export interface CheckInDecisionPayload {
+    readonly toolName: string;
+    readonly toolCallId: string;
+    readonly iteration: number;
+    /** The request the decision answered — `CheckInRequest.id` of the ask it
+     *  closes, so the record joins each decision to the one request it was for. */
+    readonly requestId: string;
+    readonly approved: boolean;
+    readonly by: string;
+    readonly note?: string;
+    /** The registered component that COLLECTED this decision (9.24.0) — the
+     *  `componentId` the ask carried. Absent when the ask was prose-only. The
+     *  decision itself is unchanged: a structured fact, never parsed from the
+     *  words a screen rendered. */
+    readonly componentId?: string;
+}
+/**
+ * One link of a `toolMiddleware` / `messageMiddleware` chain answered.
+ *
+ * Its own domain rather than a `permission.check` with a different label:
+ * a middleware decision is not a permission check, and reporting it as one
+ * would make every consumer reading that channel believe a checker they
+ * never configured had fired.
+ *
+ * Deliberately carries no `before` / `after` — the values live in the
+ * committed `middlewareDecisions` ledger, under whatever redaction the run
+ * configured. An event stream is a fan-out to sinks we do not control, and
+ * a scrubbed value should not leave the run through it.
+ */
+export interface MiddlewareDecisionPayload {
+    readonly middleware: string;
+    /** Where in the loop this happened — the vocabulary `.act()` is keyed on. */
+    readonly moment: LoopMoment;
+    /** The 7.18 spelling of the same fact. Narrow on `moment`. */
+    readonly at: 'tool' | 'message';
+    readonly phase?: 'input' | 'output';
+    readonly toolName?: string;
+    readonly toolCallId?: string;
+    readonly iteration: number;
+    readonly outcome: 'allow' | 'deny' | 'ask';
+    /** True when this link changed the value the chain carries forward. */
+    readonly changed: boolean;
+    /** The transform's `why`, the denial's `reason`, or the ask's `question`. */
+    readonly why?: string;
+    /** The registered component that COLLECTED this decision (9.24.0). Present
+     *  only on the resume-side rows of an `ask` that carried one. */
+    readonly componentId?: string;
+}

package/dist/esm/events/payloads/consent.js

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

package/dist/esm/events/payloads/consent.js.map

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