@retinue/agentkit 0.1.0

package/dist/core/content-parts.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Typed message parts — `docs/02-core-and-persistence.md`.
+ *
+ * Every part carries a schema version and is JSON-runtime validated. Provider-specific
+ * metadata may be retained in the namespaced `providerMetadata` field but cannot define
+ * application behaviour.
+ */
+import type { ArtifactId, ArtifactVersionId, BlobRef, ConversationId, FileId, InteractionId, MessageId, MessagePartId, RunId, ToolCallId } from "./ids.js";
+import type { PlatformError } from "./errors.js";
+export declare const MESSAGE_PART_TYPES: readonly ["text", "reasoning", "tool-call", "tool-result", "question", "approval", "file", "image", "citation", "source", "artifact", "status", "error"];
+export type MessagePartType = (typeof MESSAGE_PART_TYPES)[number];
+type PartBase<T extends MessagePartType> = {
+    readonly id: MessagePartId;
+    readonly type: T;
+    /** Schema version of this part's payload. Bumped on any breaking payload change. */
+    readonly schemaVersion: number;
+    readonly createdAt: string;
+    /** Namespaced, non-authoritative provider detail. Never drives application behaviour. */
+    readonly providerMetadata?: Readonly<Record<string, unknown>>;
+};
+export type TextPart = PartBase<"text"> & {
+    readonly text: string;
+};
+export type ReasoningPart = PartBase<"reasoning"> & {
+    readonly text: string;
+    /** Reasoning is pruned before recent semantic turns when the budget is tight. */
+    readonly redacted?: boolean;
+};
+export type ToolCallPart = PartBase<"tool-call"> & {
+    readonly toolCallId: ToolCallId;
+    readonly toolName: string;
+    readonly input: unknown;
+};
+export type ToolResultPart = PartBase<"tool-result"> & {
+    readonly toolCallId: ToolCallId;
+    readonly toolName: string;
+    /** Populated for inline results. Large results are spilled and referenced instead. */
+    readonly output?: unknown;
+    /** Authorized reference to an offloaded result, read back via `read_tool_output`. */
+    readonly spilledOutputRef?: BlobRef;
+    readonly truncated: boolean;
+};
+/**
+ * An answer to one question: a single value, several, or free text.
+ *
+ * Defined in `core` because both the persistence port and the HITL service need it, and either importing the
+ * other would be circular — `hitl` already imports `persistence`. `core` is self-contained by rule (R6), which
+ * makes it the only place a shared type like this can live.
+ *
+ * `string | string[]` rather than always an array: a single-select answer being `["a"]` forces every reader to
+ * unwrap it, and one of them will forget.
+ */
+export type QuestionAnswer = string | readonly string[];
+export type QuestionPart = PartBase<"question"> & {
+    readonly interactionId: InteractionId;
+    readonly questions: readonly {
+        readonly key: string;
+        readonly prompt: string;
+        /**
+         * Suggested answers. Absent means free text only.
+         *
+         * `options` alone has always been here, but a client had no way to know whether it was being offered a
+         * *choice* or a *hint* — so it had to guess, and two clients guessed differently. The two flags below make
+         * that explicit.
+         */
+        readonly options?: readonly string[];
+        /**
+         * Whether more than one option may be chosen.
+         *
+         * Explicit rather than inferred, because "pick a model" and "pick the features you want" are the same shape
+         * on the wire and completely different in a UI. A client that guessed from the prompt text would guess wrong
+         * on the first ambiguous one.
+         */
+        readonly multiple?: boolean;
+        /**
+         * Whether the person may answer with something not on the list.
+         *
+         * Defaults to allowed **when there are no options**, and to *not* allowed when there are — a closed list is
+         * usually closed on purpose. A caller wanting "one of these, or describe your own" says so.
+         */
+        readonly allowOther?: boolean;
+    }[];
+    readonly answeredAt?: string;
+};
+export type ApprovalPart = PartBase<"approval"> & {
+    readonly interactionId: InteractionId;
+    readonly toolName: string;
+    readonly summary: string;
+    readonly riskCategory: string;
+    readonly decidedAt?: string;
+};
+export type FilePart = PartBase<"file"> & {
+    readonly fileId: FileId;
+    readonly filename: string;
+    readonly mediaType: string;
+    readonly byteSize: number;
+};
+export type ImagePart = PartBase<"image"> & {
+    readonly fileId: FileId;
+    readonly mediaType: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly altText?: string;
+};
+/**
+ * Where a cited passage came from (#137).
+ *
+ * A closed union with exactly two arms, and one shape for both is AC-6: the frontend renders one thing whether
+ * a claim came from an indexed document or from the web. Two part types would mean two renderers, two schemas,
+ * and eventually two behaviours for "click the citation".
+ *
+ * The arms differ in what *resolving* means — a chunk id resolves inside this platform, a URL resolves outside
+ * it — and that difference is real, so it is a discriminant rather than a pile of optional fields.
+ */
+export type CitationOrigin = {
+    readonly kind: "retrieval";
+    readonly sourceType: "file" | "artifact" | "message" | "external";
+    readonly sourceId: string;
+    /** The chunk, which is what makes AC-2's "specific passage" resolvable rather than aspirational. */
+    readonly chunkId: string;
+    readonly chunkIndex: number;
+    /** The heading path the chunker found, when there was one. */
+    readonly locator?: string;
+} | {
+    readonly kind: "web";
+    /**
+     * The URL that was **actually read**, after redirects — not the one requested.
+     *
+     * A citation must open what was read. ShareFlow's `safefetch` exists because the two differ: a public URL
+     * can redirect somewhere else entirely, and citing the request would cite a page nobody looked at.
+     */
+    readonly url: string;
+    readonly title?: string;
+};
+/**
+ * A cited passage — REQ-030, #137.
+ *
+ * **Self-contained on purpose.** `excerpt`, `title` and `retrievedAt` are stored on the part rather than
+ * looked up from the source, because AC-4 requires an answer given months ago to remain auditable *after the
+ * source is gone*: a document deleted, a URL dead, a chunk re-indexed under a different id. A citation that
+ * resolved by fetching would be a citation that stops being evidence the moment anything changes — which is
+ * exactly when someone needs it.
+ *
+ * The duplication is the feature. This is a snapshot of what was read, not a pointer to what is there now.
+ */
+export type CitationPart = PartBase<"citation"> & {
+    readonly origin: CitationOrigin;
+    /** The exact text used. Bounded — a citation is evidence for a claim, not a copy of the source. */
+    readonly excerpt: string;
+    /** When the passage was read. A fact from last year and a fact from this morning are different claims. */
+    readonly retrievedAt: string;
+    /**
+     * The parts this citation grounds — AC-3.
+     *
+     * Groundedness is derived from *this graph* rather than flagged on the text, so it cannot disagree with
+     * itself: a text part is grounded exactly when some citation names it. A boolean on the text part would be a
+     * second place for the same fact, and the two would drift the first time a citation was withheld.
+     */
+    readonly supports: readonly MessagePartId[];
+    /** Character range within the source passage, when the producer knows it. Narrows AC-2 further. */
+    readonly charRange?: {
+        readonly start: number;
+        readonly end: number;
+    };
+};
+export type SourcePart = PartBase<"source"> & {
+    readonly sourceId: string;
+    readonly title: string;
+    readonly url?: string;
+};
+export type ArtifactPart = PartBase<"artifact"> & {
+    readonly artifactId: ArtifactId;
+    readonly versionId: ArtifactVersionId;
+    readonly title: string;
+};
+export type StatusPart = PartBase<"status"> & {
+    readonly status: string;
+    readonly detail?: string;
+};
+export type ErrorPart = PartBase<"error"> & {
+    readonly error: PlatformError;
+};
+export type MessagePart = TextPart | ReasoningPart | ToolCallPart | ToolResultPart | QuestionPart | ApprovalPart | FilePart | ImagePart | CitationPart | SourcePart | ArtifactPart | StatusPart | ErrorPart;
+export type MessageRole = "system" | "user" | "assistant" | "tool";
+export type Message = {
+    readonly id: MessageId;
+    readonly conversationId: ConversationId;
+    readonly runId?: RunId;
+    readonly role: MessageRole;
+    readonly parts: readonly MessagePart[];
+    readonly createdAt: string;
+};
+export {};
+//# sourceMappingURL=content-parts.d.ts.map

package/dist/core/content-parts.js

@@ -0,0 +1,23 @@
+/**
+ * Typed message parts — `docs/02-core-and-persistence.md`.
+ *
+ * Every part carries a schema version and is JSON-runtime validated. Provider-specific
+ * metadata may be retained in the namespaced `providerMetadata` field but cannot define
+ * application behaviour.
+ */
+export const MESSAGE_PART_TYPES = [
+    "text",
+    "reasoning",
+    "tool-call",
+    "tool-result",
+    "question",
+    "approval",
+    "file",
+    "image",
+    "citation",
+    "source",
+    "artifact",
+    "status",
+    "error",
+];
+//# sourceMappingURL=content-parts.js.map

package/dist/core/context.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Execution context — `docs/02-core-and-persistence.md`.
+ *
+ * Context identity is constructed by the host application. Model-generated input can
+ * never override it: nothing that originates in a tool argument, a skill body or an
+ * MCP tool description may reach these fields.
+ */
+import type { ConversationId, MembershipId, PrincipalId, RequestId, RoleId, RunId, TenantId } from "./ids.js";
+export type ExecutionContext = {
+    readonly tenantId: TenantId;
+    readonly principalId: PrincipalId;
+    readonly membershipId?: MembershipId;
+    readonly roleIds: readonly RoleId[];
+    readonly locale: string;
+    readonly timezone: string;
+    readonly conversationId?: ConversationId;
+    readonly runId?: RunId;
+    readonly requestId: RequestId;
+    /**
+     * True when this run must perform **no external write** — docs/07 and docs/08's shadow mode: *"old and
+     * new systems may run in shadow mode, but shadow execution performs no external writes."*
+     *
+     * On the context deliberately, and the paragraph above is the reason it is safe: shadow-ness is
+     * constructed by the host, exactly like `tenantId`, and **a model must never be able to clear it** —
+     * clearing it would turn a shadow run into a real one. A hint a model could set would not belong here;
+     * this is the opposite kind of field.
+     *
+     * Absent means a real run. That is the uncomfortable direction — a forgotten flag publishes rather than
+     * suppresses — and it is unavoidable, because defaulting to shadow would make every existing context a
+     * shadow context. The dangerous direction is closed in `defineDelegatingTool` instead: a run that *says*
+     * it is shadow and has nowhere to record the suppression is refused, not performed.
+     */
+    readonly shadow?: boolean;
+};
+/**
+ * The tenant scope every store method receives explicitly. Governing principle 1:
+ * unsafe APIs such as `findById(id)` are forbidden.
+ */
+export type TenantScope = {
+    readonly tenantId: TenantId;
+};
+/** Stable cursor pagination, required of every list method. */
+export type Page<T> = {
+    readonly items: readonly T[];
+    readonly nextCursor?: string;
+};
+export type PageRequest = {
+    readonly limit: number;
+    readonly cursor?: string;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/core/context.js

@@ -0,0 +1,9 @@
+/**
+ * Execution context — `docs/02-core-and-persistence.md`.
+ *
+ * Context identity is constructed by the host application. Model-generated input can
+ * never override it: nothing that originates in a tool argument, a skill body or an
+ * MCP tool description may reach these fields.
+ */
+export {};
+//# sourceMappingURL=context.js.map

package/dist/core/env.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reading an environment variable through the rename — #192.
+ *
+ * Every variable this platform reads was `AGENTKIT_*` and is now `RETINUE_*`. A straight rename breaks every
+ * existing deployment and every developer's `.env` at the moment they pull, with an error that says nothing about
+ * why — a missing database URL looks like a missing database URL, not like a rename.
+ *
+ * So both are read, new name first, and the old one **warns**. That gives one release where a deployment keeps
+ * working while it is corrected, and the warning is what makes the deprecation finite rather than permanent:
+ * silence would mean the fallback is still load-bearing in a year and nobody knows.
+ *
+ * The library itself reads no environment — `deployment.test.ts` enforces that. This is used by the host and the
+ * scripts, which are entry points, and reading configuration is what an entry point is for.
+ */
+export type EnvReader = (name: string) => string | undefined;
+/**
+ * `RETINUE_X`, falling back to `AGENTKIT_X`.
+ *
+ * `name` is given **without** the prefix — `read(env, "DATABASE_URL")` — so a caller cannot accidentally ask for
+ * the legacy name directly and skip the warning.
+ */
+export declare const readEnv: (env: Readonly<Record<string, string | undefined>>, name: string, warn?: (message: string) => void) => string | undefined;
+/** For tests, which need each case to see a fresh warning rather than one suppressed by an earlier case. */
+export declare const resetEnvWarnings: () => void;
+//# sourceMappingURL=env.d.ts.map

package/dist/core/env.js

@@ -0,0 +1,41 @@
+/**
+ * Reading an environment variable through the rename — #192.
+ *
+ * Every variable this platform reads was `AGENTKIT_*` and is now `RETINUE_*`. A straight rename breaks every
+ * existing deployment and every developer's `.env` at the moment they pull, with an error that says nothing about
+ * why — a missing database URL looks like a missing database URL, not like a rename.
+ *
+ * So both are read, new name first, and the old one **warns**. That gives one release where a deployment keeps
+ * working while it is corrected, and the warning is what makes the deprecation finite rather than permanent:
+ * silence would mean the fallback is still load-bearing in a year and nobody knows.
+ *
+ * The library itself reads no environment — `deployment.test.ts` enforces that. This is used by the host and the
+ * scripts, which are entry points, and reading configuration is what an entry point is for.
+ */
+const LEGACY_PREFIX = "AGENTKIT_";
+const PREFIX = "RETINUE_";
+/** Reported once per variable, so a busy worker does not print the same line on every request. */
+const warned = new Set();
+/**
+ * `RETINUE_X`, falling back to `AGENTKIT_X`.
+ *
+ * `name` is given **without** the prefix — `read(env, "DATABASE_URL")` — so a caller cannot accidentally ask for
+ * the legacy name directly and skip the warning.
+ */
+export const readEnv = (env, name, warn = (m) => console.warn(m)) => {
+    const current = env[`${PREFIX}${name}`];
+    if (current !== undefined && current !== "")
+        return current;
+    const legacy = env[`${LEGACY_PREFIX}${name}`];
+    if (legacy === undefined || legacy === "")
+        return undefined;
+    if (!warned.has(name)) {
+        warned.add(name);
+        warn(`${LEGACY_PREFIX}${name} is deprecated and will stop being read in the next minor release. ` +
+            `Rename it to ${PREFIX}${name}.`);
+    }
+    return legacy;
+};
+/** For tests, which need each case to see a fresh warning rather than one suppressed by an earlier case. */
+export const resetEnvWarnings = () => warned.clear();
+//# sourceMappingURL=env.js.map

package/dist/core/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Error contract — `docs/03-intelligence-runtime.md`.
+ *
+ * Errors carry a stable code, retryability and safe details. "Safe" means the payload
+ * is shown to a model and a user: no credentials, no connection strings, no internal
+ * hostnames, no raw provider stack traces.
+ */
+export declare const ERROR_CODES: readonly ["unauthorized", "forbidden", "not_found", "invalid_input", "conflict", "rate_limited", "provider_unavailable", "provider_error", "timeout", "cancelled", "budget_exceeded", "context_overflow", "approval_required", "approval_denied", "approval_expired", "question_pending", "idempotency_conflict", "capability_unavailable", "internal"];
+export type ErrorCode = (typeof ERROR_CODES)[number];
+export type PlatformError = {
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly retryable: boolean;
+    /** Redacted, model- and user-safe context. */
+    readonly details?: Readonly<Record<string, unknown>>;
+    readonly retryAfterMs?: number;
+};
+export declare class AgentPlatformError extends Error {
+    readonly code: ErrorCode;
+    readonly retryable: boolean;
+    readonly details: Readonly<Record<string, unknown>> | undefined;
+    readonly retryAfterMs: number | undefined;
+    constructor(error: PlatformError, options?: {
+        cause?: unknown;
+    });
+    /** The wire form. Deliberately drops `cause` and the stack. */
+    toPlatformError(): PlatformError;
+}
+export declare const isAgentPlatformError: (value: unknown) => value is AgentPlatformError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.js

@@ -0,0 +1,65 @@
+/**
+ * Error contract — `docs/03-intelligence-runtime.md`.
+ *
+ * Errors carry a stable code, retryability and safe details. "Safe" means the payload
+ * is shown to a model and a user: no credentials, no connection strings, no internal
+ * hostnames, no raw provider stack traces.
+ */
+export const ERROR_CODES = [
+    "unauthorized",
+    "forbidden",
+    "not_found",
+    "invalid_input",
+    "conflict",
+    "rate_limited",
+    "provider_unavailable",
+    "provider_error",
+    "timeout",
+    "cancelled",
+    "budget_exceeded",
+    "context_overflow",
+    "approval_required",
+    "approval_denied",
+    "approval_expired",
+    /**
+     * A tool put a question to a person and the run must park until they answer — #163.
+     *
+     * Not an error the model should work around, and deliberately not `approval_required`: an approval asks *may
+     * I do this* about a call the platform already holds, and this asks *which of these* about a call that has
+     * not been decided yet. The engine reads this code to emit `question.requested`, which is what suspends the
+     * run — before this, `question.requested` was in the event union and handled by the worker, and nothing in
+     * the platform could produce it.
+     *
+     * Carries `details.interactionId`.
+     */
+    "question_pending",
+    "idempotency_conflict",
+    "capability_unavailable",
+    "internal",
+];
+export class AgentPlatformError extends Error {
+    code;
+    retryable;
+    details;
+    retryAfterMs;
+    constructor(error, options) {
+        super(error.message, options);
+        this.name = "AgentPlatformError";
+        this.code = error.code;
+        this.retryable = error.retryable;
+        this.details = error.details;
+        this.retryAfterMs = error.retryAfterMs;
+    }
+    /** The wire form. Deliberately drops `cause` and the stack. */
+    toPlatformError() {
+        return {
+            code: this.code,
+            message: this.message,
+            retryable: this.retryable,
+            ...(this.details === undefined ? {} : { details: this.details }),
+            ...(this.retryAfterMs === undefined ? {} : { retryAfterMs: this.retryAfterMs }),
+        };
+    }
+}
+export const isAgentPlatformError = (value) => value instanceof AgentPlatformError;
+//# sourceMappingURL=errors.js.map

package/dist/core/events.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Transport events — `docs/04-durable-runtime-and-hitl.md`.
+ *
+ * Transports map these to GraphQL subscriptions, SSE or another channel without
+ * changing runtime semantics. Events carry a monotonic sequence per run so a client
+ * can resume from a cursor after reconnecting.
+ */
+import type { MessagePart } from "./content-parts.js";
+import type { PlatformError } from "./errors.js";
+import type { InteractionId, MessageId, RunId, TenantId, ToolCallId } from "./ids.js";
+export declare const RUN_EVENT_TYPES: readonly ["run.queued", "run.started", "run.checkpointed", "run.completed", "run.failed", "run.cancelled", "run.retry-pending", "part.added", "part.updated", "tool.started", "tool.completed", "tool.failed", "question.requested", "question.answered", "approval.requested", "approval.decided", "usage.updated", "context.compacted"];
+export type RunEventType = (typeof RUN_EVENT_TYPES)[number];
+type EventBase<T extends RunEventType> = {
+    readonly type: T;
+    readonly runId: RunId;
+    /** Monotonic per run. Clients resume with `after: sequence`. */
+    readonly sequence: number;
+    readonly occurredAt: string;
+};
+export type RunLifecycleEvent = EventBase<"run.queued" | "run.started" | "run.checkpointed" | "run.completed" | "run.cancelled">;
+export type RunFailedEvent = EventBase<"run.failed"> & {
+    readonly error: PlatformError;
+};
+/**
+ * Emitted when a transient failure triggers a retry (see docs/04 → Retry policy).
+ * Carries enough for a client to render "attempt 2 of 5, retrying in ~3s (rate limited)"
+ * rather than only showing the `retry-pending` status.
+ */
+export type RunRetryPendingEvent = EventBase<"run.retry-pending"> & {
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    /** When the next attempt is scheduled, honoring any `retry-after` the provider returned. */
+    readonly nextAttemptAt: string;
+    /** The transient error that triggered the retry. */
+    readonly error: PlatformError;
+};
+export type PartEvent = EventBase<"part.added" | "part.updated"> & {
+    readonly messageId: MessageId;
+    readonly part: MessagePart;
+};
+export type ToolEvent = EventBase<"tool.started" | "tool.completed" | "tool.failed"> & {
+    readonly toolCallId: ToolCallId;
+    readonly toolName: string;
+};
+export type InteractionEvent = EventBase<"question.requested" | "question.answered" | "approval.requested" | "approval.decided"> & {
+    readonly interactionId: InteractionId;
+};
+export type UsageUpdatedEvent = EventBase<"usage.updated"> & {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly costMinorUnits?: number;
+    /** When present, the worker records a durable `UsageEvent` for this realized step. */
+    readonly modelId?: string;
+    readonly cachedInputTokens?: number;
+    readonly reasoningTokens?: number;
+    /**
+     * Non-text input this step carried — #185 AC-4.
+     *
+     * On the event, not only in the cost, so the ledger can say *why* a step cost what it did. A multimodal turn
+     * and a text turn that happened to price the same are otherwise indistinguishable after the fact, which makes
+     * a pricing mistake invisible.
+     */
+    readonly imageCount?: number;
+    readonly audioSeconds?: number;
+    readonly currency?: string;
+    /** Stable per-step id so recording is idempotent across a recovery. */
+    readonly stepId?: string;
+};
+export type ContextCompactedEvent = EventBase<"context.compacted"> & {
+    readonly droppedParts: number;
+    readonly tokensReclaimed: number;
+};
+export type RunEvent = RunLifecycleEvent | RunFailedEvent | RunRetryPendingEvent | PartEvent | ToolEvent | InteractionEvent | UsageUpdatedEvent | ContextCompactedEvent;
+/** Fan-out port. Adapters: Supabase Realtime, Redis pub/sub, in-memory for tests. */
+export interface RealtimePublisher {
+    publish(channel: string, event: RunEvent): Promise<void>;
+}
+/**
+ * Durable, append-only per-run event log — the catch-up half of reconnect. Every event the worker
+ * publishes is also appended here; a reconnecting client reads everything after its cursor. Ordering
+ * is by the monotonic `sequence`, so replay is deterministic and gap-free. Adapters: Postgres,
+ * Redis list (Twenty's pattern), in-memory for tests.
+ */
+export interface RunEventLog {
+    append(input: {
+        readonly tenantId: TenantId;
+        readonly event: RunEvent;
+    }): Promise<void>;
+    /** Events with `sequence > after`, ascending. `after: 0` returns the whole run. */
+    listAfter(input: {
+        readonly tenantId: TenantId;
+        readonly runId: RunId;
+        readonly after: number;
+        readonly limit?: number;
+    }): Promise<readonly RunEvent[]>;
+    latestSequence(input: {
+        readonly tenantId: TenantId;
+        readonly runId: RunId;
+    }): Promise<number>;
+}
+/** A tool call started but not yet resolved, tracked while projecting a run's event stream. */
+export type StreamPendingToolCall = {
+    readonly toolCallId: ToolCallId;
+    readonly toolName: string;
+    readonly startedAt: string;
+};
+/**
+ * The deterministic projection of a run's event stream: the assistant message parts plus the
+ * accounting/interaction state a client needs to render. It is a pure fold over `RunEvent`s, so the
+ * server (worker checkpoint) and any client rebuild identical state from the same events — the
+ * single source of truth that makes reconnect produce no missing or duplicated parts.
+ */
+export type RunStreamState = {
+    readonly parts: readonly MessagePart[];
+    readonly pendingToolCalls: readonly StreamPendingToolCall[];
+    readonly usage: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+        readonly costMinorUnits: number;
+    };
+    /** Highest sequence folded in. Use as the reconnect cursor. */
+    readonly sequence: number;
+    readonly lastEventType?: RunEventType;
+    /** Present between retry attempts, cleared as soon as the run makes progress again. */
+    readonly retry?: {
+        readonly attempt: number;
+        readonly maxAttempts: number;
+        readonly nextAttemptAt: string;
+    };
+    readonly error?: PlatformError;
+    readonly terminal: boolean;
+};
+export declare const EMPTY_RUN_STREAM_STATE: RunStreamState;
+/** Fold one event into the projection. Pure; ignores events with a sequence already folded. */
+export declare const reduceRunEvent: (state: RunStreamState, event: RunEvent) => RunStreamState;
+/** Project a full (or partial) event sequence into `RunStreamState`. */
+export declare const reduceRunEvents: (events: Iterable<RunEvent>, initial?: RunStreamState) => RunStreamState;
+export {};
+//# sourceMappingURL=events.d.ts.map