@teaflask/assistant 0.6.0 → 0.7.0

package/dist/core/tool-call-display.d.ts

@@ -1,27 +1,98 @@
+/**
+ * Where a call is in its life. "input-streaming" means the agent is still
+ * writing the arguments, "input-available" means they are complete and the call
+ * is running or waiting for approval, "output-available" means it finished with
+ * a result, and "output-error" means it failed; "denied" means the user didn't
+ * approve it, "cancelled" means it never ran, "refused" means Teaflask declined
+ * it before it reached the tool, and "superseded" means it started but was cut
+ * off when the run restarted, so its result never arrived.
+ */
 export type ToolCallState = "input-streaming" | "input-available" | "output-available" | "output-error" | "denied" | "cancelled" | "refused" | "superseded";
+/**
+ * Server-supplied display details for one tool call, namely its row's label,
+ * icon and view.
+ */
 export interface ToolCallDisplay {
+    /**
+     * A few words the agent wrote saying what the step is for. When present it
+     * is the row's label in every state, followed by a short state word if the
+     * call failed, was not approved, didn't run, was declined or didn't finish.
+     */
     caption?: string;
+    /** The row's label while the call runs, used when there is no caption. */
     progressText?: string;
+    /**
+     * The row's label once the call succeeds, used when there is no caption.
+     */
     completeText?: string;
+    /** The row's label when the call fails, used when there is no caption. */
     errorText?: string;
+    /**
+     * The kind of work the call is, one of TOOL_CALL_ICONS. Any other value
+     * shows the generic icon.
+     */
     icon?: string;
+    /**
+     * The view the server names for this call, as a key and version. A registry
+     * entry under that exact key with the same version is preferred over a
+     * match by tool name; Teaflask's own tools name built-in views with keys
+     * starting `teaflask.`.
+     */
     view?: {
         key: string;
         version: number;
     };
 }
+/**
+ * One tool or action call as a transcript row renders it. A custom `toolRow`
+ * receives it as `view`, and toolCallPresentationOf takes it.
+ */
 export interface ToolCallViewModel {
+    /** The tool's name. For an action, `action__<slug>`. */
     toolName: string;
+    /** Where the call is in its life. See ToolCallState. */
     state: ToolCallState;
+    /** Unique id of the call, when known. */
     toolCallId?: string;
+    /**
+     * The arguments as pretty-printed JSON, or the raw text while it is still
+     * streaming in.
+     */
     input: string;
+    /** The arguments as raw JSON text, exactly as streamed. */
     argsText?: string;
+    /**
+     * The raw result text. Undefined until the call finishes, and withheld for
+     * calls that failed, were not approved, didn't run, were declined or had
+     * their result replaced by a preview.
+     */
     output?: string;
+    /**
+     * True when the result was too large for the agent and was replaced by a
+     * shortened preview. `output` is then withheld.
+     */
     offloaded?: boolean;
+    /** Why the call failed, set when it failed. */
     errorText?: string;
+    /**
+     * Teaflask's reason for declining the call, set only when `state` is
+     * "refused".
+     */
     refusalText?: string;
+    /**
+     * The server's display details for the call (label text, icon, view), when
+     * it sent any.
+     */
     display?: ToolCallDisplay;
+    /**
+     * The JSON Schema of the tool's arguments, when it declared one. Undefined
+     * otherwise, never `{}`.
+     */
     argsSchema?: Record<string, unknown>;
+    /**
+     * The JSON Schema of the tool's successful result, when it declared one.
+     * Undefined otherwise.
+     */
     resultSchema?: Record<string, unknown>;
 }
 export declare function humanizedToolName(name: string): string;

package/dist/core/tool-call-presentation.d.ts

@@ -1,15 +1,48 @@
 import type { ToolCallState, ToolCallViewModel } from "./tool-call-display.js";
 import type { ToolViewRegistry, ToolViewResolution } from "./tool-view.js";
+/**
+ * Every icon kind a tool call row can show: search, file, terminal (running a
+ * command), question (asking the user), memory, delegation (sub-agents),
+ * routine (finding or preparing actions), todo, navigation (opening, reading or
+ * filling in your page) and generic.
+ */
 export declare const TOOL_CALL_ICONS: readonly ["search", "file", "terminal", "question", "memory", "delegation", "routine", "todo", "navigation", "generic"];
+/** One icon kind from TOOL_CALL_ICONS. */
 export type ToolCallIcon = (typeof TOOL_CALL_ICONS)[number];
+/**
+ * Everything needed to render one tool call row, as returned by
+ * toolCallPresentationOf.
+ */
 export interface ToolCallPresentation {
+    /**
+     * The row's label. It is the agent's caption or the server's text when
+     * there is one, else wording built from the tool name and state, such as
+     * "Running create ticket…" or "create ticket failed".
+     */
     headline: string;
+    /**
+     * The icon kind to show; "generic" when the server named none or one this
+     * version doesn't know.
+     */
     icon: ToolCallIcon;
+    /** The call's state. */
     status: ToolCallState;
-    settledSummary: string;
+    /**
+     * The call's running-state label, whatever its actual state. Used for a
+     * sub-agent's line saying what it is doing now.
+     */
     currentWorkLabel: string;
+    /**
+     * The tool views and icons that match the call, and the call they receive.
+     */
     toolView: ToolViewResolution;
 }
+/**
+ * Works out everything needed to render one tool call row: its label, icon,
+ * state, its running-state label and matching tool view. Pass your `toolViews`
+ * registry, and `awaitingDecision: true` while an approval or question tied to
+ * the call is waiting on the user.
+ */
 export declare function toolCallPresentationOf(view: ToolCallViewModel, registry?: ToolViewRegistry, options?: {
     awaitingDecision?: boolean;
 }): ToolCallPresentation;

package/dist/core/tool-call-presentation.js

@@ -23,7 +23,6 @@ export function toolCallPresentationOf(view, registry, options) {
         headline,
         icon: _iconOf(view.display?.icon),
         status: view.state,
-        settledSummary: headline,
         currentWorkLabel: toolRowHeadlineOf({ ...view, state: "input-available" }),
         toolView: {
             views: resolved.views,

package/dist/core/tool-schema-anchors.d.ts

@@ -1,7 +1,13 @@
 import type { AgentSubscriber } from "@ag-ui/client";
 import type { JsonSchema } from "./tool-view.js";
+/**
+ * The JSON Schemas a tool declared. Either field is absent when that schema was
+ * not declared.
+ */
 export interface ToolCallSchemas {
+    /** The JSON Schema of the tool's arguments. */
     argsSchema?: JsonSchema;
+    /** The JSON Schema of the tool's successful result. */
     resultSchema?: JsonSchema;
 }
 export declare const EMPTY_TOOL_SCHEMA_ANCHORS: ReadonlyMap<string, ToolCallSchemas>;

package/dist/core/tool-view.d.ts

@@ -1,62 +1,235 @@
 import type { ToolCallState } from "./tool-call-display.js";
+/** The palette a tool view renders in. */
 export type ToolViewThemeMode = "light" | "dark";
+/** A JSON Schema document, passed through as received and never validated. */
 export type JsonSchema = Record<string, unknown>;
+/**
+ * One tool or action call, as a tool view receives it. You get a fresh copy
+ * through `update` as the call progresses; never mutate it.
+ */
 export interface ToolViewCall<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The tool's name. For an action, `action__<slug>`. */
     toolName: string;
+    /**
+     * Unique id of the call, stable for its whole life and equal to the
+     * `data-tf-tool-call-id` attribute on its row. Empty when the call has no
+     * id.
+     */
     toolCallId: string;
+    /** Where the call is in its life. See ToolCallState for each value. */
     status: ToolCallState;
+    /**
+     * True while an approval or a question tied to this call is waiting on the
+     * user. The view may say so, but the decision itself happens in the
+     * assistant's own card, never in the view.
+     */
     awaitingDecision: boolean;
+    /**
+     * The arguments the agent passed, parsed, without the short caption the
+     * agent writes for each step; `{}` while they are still streaming in or if
+     * they are not a JSON object. For an action, `{ path_params, query, body
+     * }`, with one key for each part your API operation declares.
+     */
     args: TArgs;
+    /**
+     * The parsed result once the call has finished; for an action, your API's
+     * response body alone (read the HTTP status with
+     * `actionEnvelopeOf(resultText)`). Undefined until the result arrives, when
+     * it is not JSON, or when `truncated` is true.
+     */
     result?: TResult;
+    /**
+     * The raw result text as recorded. Undefined until the call finishes, and
+     * withheld for calls that failed, were not approved, didn't run, were
+     * declined or had their result replaced by a preview.
+     */
     resultText?: string;
+    /**
+     * True when the result was cut to fit a size limit. `result` is then
+     * undefined and `resultText` holds only the cut text, so don't show it as
+     * complete.
+     */
     truncated?: boolean;
+    /**
+     * True when the result was too large for the agent and was replaced by a
+     * shortened preview. The tool's real output is not available to the view.
+     */
     offloaded?: boolean;
+    /**
+     * Why the call failed, set when it failed. Use humanFailureSentenceOf to
+     * get a sentence fit for the user, and actionFailureOf to read an action's
+     * HTTP status, error code and per-field problems.
+     */
     errorText?: string;
+    /**
+     * Teaflask's reason for declining the call, set when `status` is "refused".
+     */
     refusalText?: string;
+    /**
+     * The JSON Schema of the tool's arguments, when it declared one. For an
+     * action, built from your operation's path, query and body schemas;
+     * undefined (never `{}`) otherwise, so a view must still work without it.
+     */
     argsSchema?: JsonSchema;
+    /**
+     * The JSON Schema of the tool's successful result, when it declared one.
+     * For an action, your operation's success response body schema, which
+     * matches `result`; undefined otherwise.
+     */
     resultSchema?: JsonSchema;
 }
+/** What a tool view's `mount` and `update` receive. */
 export interface ToolViewProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The call to draw. */
     call: ToolViewCall<TArgs, TResult>;
+    /**
+     * `themeMode` is the palette the assistant is actually painted in, "light"
+     * or "dark", with an "auto" setting already resolved. A change arrives
+     * through `update`.
+     */
     context: {
         themeMode: ToolViewThemeMode;
     };
 }
+/** A mounted tool view, as returned from `mount`. */
 export interface ToolViewInstance<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called with new props whenever the call changes (arguments arrive, status
+     * advances, the result lands, an approval opens or settles) or the theme
+     * changes. Apply them to the existing view so the user's state in it
+     * survives; a throw makes the assistant show the next matching view.
+     */
     update(props: ToolViewProps<TArgs, TResult>): void;
+    /**
+     * Called when the view is removed. Release any listeners, timers or roots
+     * you created.
+     */
     destroy(): void;
 }
+/**
+ * A tool view, which draws one tool or action call inside its row in the
+ * conversation in place of the default view of its arguments. Write one
+ * directly for plain DOM or any framework, or create one from a React component
+ * with reactToolView.
+ */
 export interface ToolViewAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called once per call, even while its row is collapsed. Draw into
+     * `container` (the assistant owns it) and return the instance that receives
+     * updates; if `mount` throws, the error goes to the provider's `onError`
+     * and the next matching view is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
+/**
+ * A custom icon for a tool call, drawn in place of the default glyph in the
+ * small mark beside the row's label. Same mount, update and destroy lifecycle
+ * as a view; reactToolView can create one from a React component.
+ */
 export interface IconAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Draws the icon into `container` and returns the instance that receives
+     * later updates and teardown. If it throws, the next matching icon or the
+     * default glyph is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
+/** One entry in your tool-view registry, carrying a view, an icon, or both. */
 export interface ToolViewRegistration {
-    version: number;
+    /**
+     * Leave it out for your own tools and actions; they match by tool name,
+     * which ignores it. It only matters for a view key the server names, which
+     * must match this version exactly.
+     */
+    version?: number;
+    /**
+     * Draws the call in its row's body, replacing the default view of its
+     * arguments.
+     */
     view?: ToolViewAdapter;
+    /**
+     * Replaces the glyph in the small mark beside the row's label. The mark's
+     * frame stays.
+     */
     icon?: IconAdapter;
 }
+/**
+ * Your tool views, keyed by tool name (for an action, `action__<slug>`; see
+ * actionToolViews) or by a view key the server names, and passed as `toolViews`
+ * on the provider or the script-tag element. Keys starting with `teaflask.` are
+ * reserved and ignored.
+ */
 export type ToolViewRegistry = Readonly<Record<string, ToolViewRegistration>>;
 export declare function isReservedToolViewKey(key: string): boolean;
 export declare const PACKAGE_TOOL_VIEWS: ToolViewRegistry;
+/**
+ * Returns the tool name an action runs under, `action__<slug>`, where the slug
+ * is the one shown for the action on its Actions page in Teaflask.
+ */
 export declare function actionToolName(slug: string): string;
+/**
+ * Builds a tool-view registry keyed by action slug instead of tool name, by
+ * turning each slug into `action__<slug>`. Spread the result beside a registry
+ * of ordinary tool names and pass both as `toolViews`.
+ */
 export declare function actionToolViews(bySlug: Readonly<Record<string, ToolViewRegistration>>): ToolViewRegistry;
+/** One tool view that matches a call, and how it matched. */
 export interface ResolvedToolView {
+    /**
+     * How the view matched, where lower wins. 1 is your registry by the view
+     * key and version the server named for this call, 2 is your registry by the
+     * call's exact tool name (for an action, `action__<slug>`), and 3 is a view
+     * built into the package; because 2 beats 3, registering under a built-in
+     * tool's name replaces its view, and with no match at all the package's
+     * default view of the arguments is shown.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The view to mount. */
     adapter: ToolViewAdapter;
 }
+/** One tool-call icon that matches a call, and how it matched. */
 export interface ResolvedToolViewIcon {
+    /**
+     * How the icon matched, with the same meaning as ResolvedToolView.rung. 1
+     * is your registry by the server-named view key and version, 2 is your
+     * registry by exact tool name, and 3 is a built-in.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The icon to mount. */
     adapter: IconAdapter;
 }
+/**
+ * The views and icons that match one call, best first, plus the call they will
+ * receive.
+ */
 export interface ToolViewResolution {
+    /**
+     * Matching views, best first. The first that mounts without throwing is
+     * shown; an empty list means the default view of the arguments.
+     */
     views: readonly ResolvedToolView[];
+    /** Matching icons, best first. An empty list means the default glyph. */
     icons: readonly ResolvedToolViewIcon[];
+    /** The call the matched view receives, built the first time it is read. */
     call: ToolViewCall;
 }
+/**
+ * Finds the registered views and icons that match one tool call, best first,
+ * from the view the server named for it (if any), its tool name and your
+ * registry. The assistant does this for you; call it only if you render tool
+ * calls yourself, and treat an empty `views` list as "use the default view of
+ * the arguments".
+ */
 export declare function resolvedToolViewsOf(ref: {
     key: string;
     version: number;

package/dist/core/transcript-rows.d.ts

@@ -1,7 +1,7 @@
 import type { Message } from "@ag-ui/core";
 import type { TurnAttachment } from "../contract/threads.js";
 import type { UserTurnMeta } from "./user-turn-ledger.js";
-import type { MarkerAnchorsSnapshot } from "./connection-epoch.js";
+import type { TranscriptMarkers } from "./connection-epoch.js";
 import { type MemoryUpdated } from "./memory-provenance-anchors.js";
 import type { BlockTiming } from "./segment-timing.js";
 import { type SubagentGroupRow } from "./subagent-rows.js";
@@ -10,61 +10,196 @@ import type { AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
 import type { ToolCallDisplay, ToolCallState } from "./tool-call-display.js";
 import type { ToolCallSchemas } from "./tool-schema-anchors.js";
 export type MarkerPosition = "before" | "after";
+/** A message the user sent. */
 export interface UserMessageRow {
+    /** Identifies a user message row. */
     kind: "user";
+    /** Stable unique key for this row, which is also the user message's id. */
     key: string;
+    /** What the user typed. Empty when the message carries only attachments. */
     text: string;
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
+    /**
+     * When the message was sent, as an ISO-8601 timestamp from the server.
+     * Absent on an optimistic row and when transcriptRowsOf was given no turn
+     * metadata.
+     */
     createdAt?: string;
+    /**
+     * True while the message has been sent but not yet confirmed by the
+     * conversation; it already sits in its final position.
+     */
     optimistic?: true;
 }
+/** A block of the assistant's reply text. */
 export interface AssistantTextRow {
+    /** Identifies an assistant reply row. */
     kind: "assistant-text";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /**
+     * The reply as Markdown. While `streaming` is true it may end mid-sentence
+     * or mid-syntax.
+     */
     text: string;
+    /**
+     * True only on the newest reply text while the assistant is still working,
+     * meaning the text is still growing.
+     */
     streaming: boolean;
+    /**
+     * Memories the assistant saved during the run that produced this message,
+     * in the order they were saved. Absent when it saved none.
+     */
     memoryUpdates?: MemoryUpdated[];
 }
+/**
+ * The model's visible thinking before or between its replies and tool calls.
+ */
 export interface ReasoningRow {
+    /** Identifies a reasoning row. */
     kind: "reasoning";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The reasoning text. */
     text: string;
+    /**
+     * True while this is the newest message and the assistant is still working;
+     * turns false as soon as reply text or a tool call starts, which is a good
+     * moment to collapse it.
+     */
     streaming: boolean;
+    /**
+     * When the reasoning started and ended by the server's clock. Absent when
+     * the history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
 }
+/**
+ * One tool or action call the agent made, with its arguments, state and result.
+ */
 export interface ToolCallRow {
+    /** Identifies a tool call row. */
     kind: "tool-call";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The call's id, which also keys this call in the markerAnchors maps. */
     toolCallId: string;
+    /**
+     * The name of the tool the agent called; an action appears as
+     * `action__<slug>`.
+     */
     toolName: string;
+    /**
+     * Where the call stands. output-available means the result arrived,
+     * output-error it failed, denied the user declined its approval, cancelled
+     * it was stopped before it ran, refused the tool declined the request,
+     * superseded a retry abandoned it, input-available it awaits its result
+     * while the assistant works, and input-streaming it has no result while the
+     * assistant is not working (for example, paused for an approval).
+     */
     state: ToolCallState;
+    /**
+     * The arguments as raw JSON text, which may be incomplete while they are
+     * still streaming.
+     */
     argsText: string;
+    /**
+     * The result text exactly as the agent received it. Undefined until it
+     * arrives.
+     */
     result?: string;
+    /**
+     * True when the tool's output was too large and `result` holds a shortened
+     * stand-in rather than the actual output; show a "result shortened" note
+     * instead of the content.
+     */
     offloaded: boolean;
+    /** Why the call failed. Present only when state is output-error. */
     errorText?: string;
+    /**
+     * The tool's explanation for declining the request. Present only when state
+     * is refused.
+     */
     refusalText?: string;
+    /**
+     * Captions, status text, an icon and a tool view reference supplied by the
+     * server for this call. Absent when it supplied none.
+     */
     display?: ToolCallDisplay;
+    /**
+     * The JSON Schemas declared for this tool's arguments and result. Absent
+     * when the tool declared none.
+     */
     schemas?: ToolCallSchemas;
+    /**
+     * When the call started and finished by the server's clock. Absent when the
+     * history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
+    /**
+     * True when the user was asked to approve this call or answer a question
+     * for it; it stays true after the decision and after a reload.
+     */
     decisionBearing?: boolean;
 }
+/**
+ * A notice shown after the last message of a turn that failed for a reason
+ * outside any single tool call, such as the model provider, usage limits or a
+ * lost connection.
+ */
 export interface TurnFailedReceiptsRow {
+    /** Identifies a failed-turn notice row. */
     kind: "turn-failed-receipts";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /**
+     * Sentences explaining the failure, written to be shown to the user as they
+     * are.
+     */
     receipts: AnchoredTurnFailReceipts[MarkerPosition];
 }
+/**
+ * A divider shown before the assistant's reply in a turn it started on its own
+ * to report finished sub-agent results; such turns have no user message.
+ */
 export interface SubagentDeliveryRow {
+    /** Identifies a sub-agent delivery divider row. */
     kind: "subagent-delivery";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The finished sub-agents whose results this turn reports. */
     results: DeliveredResult[];
 }
+/** One row of the transcript. Switch on `kind` to pick how to render it. */
 export type TranscriptRow = UserMessageRow | AssistantTextRow | ReasoningRow | ToolCallRow | SubagentGroupRow | TurnFailedReceiptsRow | SubagentDeliveryRow;
+/**
+ * A message the user has just sent that the transcript does not contain yet,
+ * shown optimistically until it arrives.
+ */
 export interface PendingUserEcho {
+    /**
+     * Temporary id for the message; it switches to the message's real id once
+     * the send succeeds, so the echo is dropped when that row arrives.
+     */
     messageId: string;
+    /** What the user typed. */
     text: string;
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
 }
-export declare function transcriptRowsOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
+/**
+ * Builds the transcript rows from the raw message list and its extra facts,
+ * exactly as useTranscript does. Pure; call it only when you need to derive
+ * rows from your own inputs.
+ */
+export declare function transcriptRowsOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
+/**
+ * Appends the just-sent user message to the rows as an optimistic user row,
+ * unless a user row with the same key is already present. Returns the rows
+ * unchanged when `echo` is null.
+ */
 export declare function withPendingUserEcho(rows: readonly TranscriptRow[], echo: PendingUserEcho | null): readonly TranscriptRow[];
 export declare function trailingRowIsStreaming(rows: readonly TranscriptRow[]): boolean;
 export declare function errorTextOf(recordedError: string | undefined, result: string | undefined): string | undefined;
@@ -77,7 +212,7 @@ export interface TranscriptBlock {
     messageId: string;
     rows: TranscriptRow[];
 }
-export declare function transcriptBlocksOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
+export declare function transcriptBlocksOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
     markerBoundaries?: MarkerBoundaries;
     attachmentsByMessageId?: ReadonlyMap<string, TurnAttachment[]>;
 }): TranscriptBlock[];

package/dist/core/turn-failed-anchors.d.ts

@@ -1,5 +1,9 @@
 import { receiptOf, wellFormedReceiptAnchorsOf, withReceiptAnchored, type AnchoredReceipts } from "./receipt-anchors.js";
 import type { AgentSubscriber } from "@ag-ui/client";
+/**
+ * The failure sentences for a failed turn, split by whether they are shown
+ * before or after the message they belong to.
+ */
 export type AnchoredTurnFailReceipts = AnchoredReceipts;
 export declare const EMPTY_TURN_FAILED_ANCHORS: ReadonlyMap<string, AnchoredTurnFailReceipts>;
 export declare const turnFailedReceiptOf: typeof receiptOf;

package/dist/core/user-turn-ledger.d.ts

@@ -8,8 +8,11 @@ export interface UserTurnRecord {
     attachments: TurnAttachment[];
     createdAt: string;
 }
+/** The send time and attachments of one user message. */
 export interface UserTurnMeta {
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
+    /** When the message was sent, as an ISO-8601 timestamp from the server. */
     createdAt: string;
 }
 export interface InjectableTurnLedger {

package/dist/generated/models/apiErrorCode.d.ts

@@ -21,6 +21,7 @@ export declare const ApiErrorCode: {
     readonly DOC_SLUG_RESERVED: "DOC_SLUG_RESERVED";
     readonly DOC_REVISION_NOT_PUBLISHABLE: "DOC_REVISION_NOT_PUBLISHABLE";
     readonly DOC_REVISION_NOT_DISCARDABLE: "DOC_REVISION_NOT_DISCARDABLE";
+    readonly DOC_PROPOSAL_STALE: "DOC_PROPOSAL_STALE";
     readonly DOC_LIMIT_REACHED: "DOC_LIMIT_REACHED";
     readonly HELP_SITE_CONFIG_INVALID: "HELP_SITE_CONFIG_INVALID";
     readonly HELP_SITE_NEVER_PUBLISHED: "HELP_SITE_NEVER_PUBLISHED";

package/dist/generated/models/apiErrorCode.js

@@ -20,6 +20,7 @@ export const ApiErrorCode = {
     DOC_SLUG_RESERVED: "DOC_SLUG_RESERVED",
     DOC_REVISION_NOT_PUBLISHABLE: "DOC_REVISION_NOT_PUBLISHABLE",
     DOC_REVISION_NOT_DISCARDABLE: "DOC_REVISION_NOT_DISCARDABLE",
+    DOC_PROPOSAL_STALE: "DOC_PROPOSAL_STALE",
     DOC_LIMIT_REACHED: "DOC_LIMIT_REACHED",
     HELP_SITE_CONFIG_INVALID: "HELP_SITE_CONFIG_INVALID",
     HELP_SITE_NEVER_PUBLISHED: "HELP_SITE_NEVER_PUBLISHED",