@appsolutely-io/waypoint 0.0.0-stage → 0.1.1-next.0

package/etc/index.api.md

@@ -0,0 +1,2159 @@
+## API Report File for "@appsolutely-io/waypoint"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public (undocumented)
+export function asProblem(error: unknown, id: string): Problem;
+
+// @public (undocumented)
+export interface AttachmentPort {
+    // (undocumented)
+    remove(id: string): MaybePromise<void>;
+    // (undocumented)
+    upload(data: Uint8Array, context: {
+        conversationId: string;
+        fileName: string;
+        contentType: string;
+    }): MaybePromise<{
+        id: string;
+    }>;
+}
+
+// @public (undocumented)
+export function bindFlow(flow: Flow, values: Record<string, unknown>): {
+    operation: string;
+    arguments: Record<string, unknown>;
+}[];
+
+// @public (undocumented)
+export type Block = BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | BlockFormFill | ExtensionBlock;
+
+// @public (undocumented)
+export interface BlockButtons {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        actions: {
+            id: string;
+            label: string;
+        }[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'buttons';
+}
+
+// @public (undocumented)
+export interface BlockCard {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        title: string;
+        blocks: Block[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'card';
+}
+
+// @public (undocumented)
+export interface BlockChoice {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        mode: 'single' | 'multi' | 'text';
+        options: string[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'choice';
+}
+
+// @public
+export interface BlockDetails {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    body: {
+        summary: string;
+        blocks: Block[];
+    };
+    fallback: string;
+    id: string;
+    type: 'details';
+}
+
+// @public (undocumented)
+export interface BlockDiff {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        before: unknown;
+        after: unknown;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'diff';
+}
+
+// @public (undocumented)
+export function blockFallback(block: {
+    type: string;
+    id?: string;
+    fallback: string;
+}): {
+    text: string;
+    disabled: true;
+    update: true;
+};
+
+// @public (undocumented)
+export interface BlockForm {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        fields: {
+            name: string;
+            label: string;
+            required?: boolean;
+            value?: string;
+        }[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'form';
+}
+
+// @public (undocumented)
+export interface BlockFormFill {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        requestId: string;
+        values: {
+            [k: string]: FormFillValue;
+        };
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'form.fill';
+}
+
+// @public (undocumented)
+export interface BlockList {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        items: string[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'list';
+}
+
+// @public (undocumented)
+export interface BlockMarkdown {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        text: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'markdown';
+}
+
+// @public (undocumented)
+export interface BlockNotice {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        text: string;
+        tone?: 'info' | 'warning' | 'error';
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'notice';
+}
+
+// @public (undocumented)
+export interface BlockPlan {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        planId: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'plan';
+}
+
+// @public (undocumented)
+export interface BlockRouteLink {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        label: string;
+        route: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'route-link';
+}
+
+// @public (undocumented)
+export interface BlockTable {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        columns: string[];
+        rows: unknown[][];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'table';
+}
+
+// @public (undocumented)
+export type BuiltinFlowTab = "favourites" | "most-used" | "recent" | "presets";
+
+// @public (undocumented)
+export interface CanonicalRequest {
+    // (undocumented)
+    body: string;
+    // (undocumented)
+    digest: string;
+    // (undocumented)
+    headers: {
+        [k: string]: string;
+    };
+    // (undocumented)
+    method: 'POST' | 'PUT' | 'PATCH' | 'GET';
+    // (undocumented)
+    path: string;
+}
+
+// @public (undocumented)
+export function canTransition(from: PlanState, to: PlanState): boolean;
+
+// @public (undocumented)
+export const CAPABILITIES: readonly ["plans", "flows", "widgets", "step-up", "scheduled", "form-fill", "plan-recovery", "plan-leave", "plan-keep", "reply-stop"];
+
+// @public (undocumented)
+export type Capability = (typeof CAPABILITIES)[number];
+
+// @public
+export type CardAnswer = {
+    kind: 'action';
+    clientReplyId: string;
+    blockId: string;
+    actionId: string;
+} | {
+    kind: 'form';
+    clientReplyId: string;
+    blockId: string;
+    values?: {};
+};
+
+// @public (undocumented)
+export interface ClientConfig {
+    // (undocumented)
+    accountId: string;
+    // (undocumented)
+    beforeSend?: (reply: Reply) => MaybePromise<Reply | false | void>;
+    // (undocumented)
+    contributions?: readonly ComposerContribution[];
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    feedback?: FeedbackPort;
+    // (undocumented)
+    flowOperations?: readonly string[];
+    // (undocumented)
+    flowSource?: FlowSource;
+    // (undocumented)
+    formSession?: FormSession;
+    // (undocumented)
+    plans?: RunnerPorts & {
+        resume?(id: string): Promise<PlanRecord>;
+        retryUndo?(id: string): Promise<PlanRecord>;
+    };
+    // (undocumented)
+    platform: PlatformPorts;
+    // (undocumented)
+    reads?: ReadPorts;
+    // (undocumented)
+    storage?: StoragePort;
+    // (undocumented)
+    tabs?: readonly FlowTab[];
+    // (undocumented)
+    transport: TransportPort;
+    // (undocumented)
+    versions?: MessageVersionPort;
+}
+
+// @public (undocumented)
+export interface ClientSnapshot {
+    // (undocumented)
+    announcement: number;
+    // (undocumented)
+    capabilities: readonly Capability[];
+    confirmationRefusal?: {
+        token: string;
+        problemId: string;
+    };
+    // (undocumented)
+    conversation: Conversation | null;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    conversationUnavailable: boolean;
+    // (undocumented)
+    draft: string;
+    // (undocumented)
+    flows: Partial<Record<string, FlowSummary[]>>;
+    // (undocumented)
+    flowTab: string;
+    // (undocumented)
+    flowTabs: readonly FlowTab[];
+    // (undocumented)
+    hints: readonly string[];
+    // (undocumented)
+    intentAlert: IntentAlert | null;
+    intentNotice: IntentNotice | null;
+    intentOverlays: Readonly<Record<string, IntentOverlay>>;
+    // (undocumented)
+    observerFailures: number;
+    // (undocumented)
+    pending: readonly PendingSend[];
+    // (undocumented)
+    plan: PlanRecord | null;
+    planReadOnly?: boolean;
+    // (undocumented)
+    problem: Problem | null;
+    // (undocumented)
+    protocol: string | null;
+    // (undocumented)
+    replyState: ReplyState;
+    restored: readonly RestoredMessage[];
+    // (undocumented)
+    sending: boolean;
+    // (undocumented)
+    status: string;
+    streamUnavailable: boolean;
+    toolSteps: readonly ToolStep[];
+    withdrawing: readonly string[];
+}
+
+// @public (undocumented)
+export interface ComposerContribution {
+    // (undocumented)
+    evaluate(context: {
+        draft: string;
+        conversationId: string;
+    }): MaybePromise<{
+        hold?: string;
+        hint?: string;
+        payload?: unknown;
+    }>;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export interface ConfirmationItem {
+    // (undocumented)
+    after?: string;
+    // (undocumented)
+    before?: string;
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    note?: string;
+}
+
+// @public
+export function confirmationOf(plan: PlanRecord | null | undefined, conversationId: string | undefined): ConfirmationRecord | undefined;
+
+// @public
+export interface ConfirmationRecord {
+    // (undocumented)
+    actionLabel?: string;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    expiresAt: string;
+    // (undocumented)
+    heading: string;
+    // (undocumented)
+    irreversible: boolean;
+    items: ConfirmationItem[];
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    schedule?: ConfirmationSchedule;
+    // (undocumented)
+    token: string;
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    verificationCount: number;
+}
+
+// @public (undocumented)
+export interface ConfirmationSchedule {
+    // (undocumented)
+    end: string | null;
+    // (undocumented)
+    endText: string;
+    // (undocumented)
+    start: string | null;
+    // (undocumented)
+    startText: string;
+}
+
+// @public
+export const CONFORMANCE_UNAVAILABLE: {
+    readonly code: "retryable";
+    readonly id: "conformance-load";
+};
+
+// @public (undocumented)
+export type ConformanceBlock = Block;
+
+// @public (undocumented)
+export interface ConformanceConfig {
+    // (undocumented)
+    baseUrl: string;
+    // (undocumented)
+    noStepUp?: boolean;
+    // (undocumented)
+    profile: "admin-host" | "app-host";
+    // (undocumented)
+    request: HttpRequest;
+}
+
+// @public (undocumented)
+export interface ConformanceResult {
+    // (undocumented)
+    failures: string[];
+    // (undocumented)
+    passed: boolean;
+    // (undocumented)
+    scenarios: string[];
+}
+
+// @public (undocumented)
+export type Conversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    id: string;
+    title: string;
+    messages: Message[];
+    replyOverdueAt?: number | null;
+    replyStatus?: 'expected' | 'unavailable' | 'failed' | 'complete';
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+};
+
+// @public (undocumented)
+export class ConversationReadError extends Error {
+    constructor(conversationId: string, status: number, problem?: unknown);
+    // (undocumented)
+    readonly conversationId: string;
+    readonly problem?: Problem;
+    // (undocumented)
+    readonly status: number;
+}
+
+// @public (undocumented)
+export type ConversationReadResult = {
+    kind: "loaded";
+    conversationId: string;
+    conversation: Conversation;
+} | {
+    kind: "missing";
+    conversationId: string;
+    status: 404 | 410;
+} | {
+    kind: "unavailable" | "superseded";
+    conversationId: string;
+};
+
+// @public (undocumented)
+export interface ConversationSource {
+    // (undocumented)
+    create(input: CreateConversation): MaybePromise<Conversation>;
+    // (undocumented)
+    list(subjectKey?: string): MaybePromise<ConversationSummary[]>;
+}
+
+// @public (undocumented)
+export interface ConversationSummary {
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    mode?: "form-fill";
+    // (undocumented)
+    parentConversationId?: string;
+    // (undocumented)
+    subject?: FormSubject;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export type CreateConversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    title: string;
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+    clientCreationId?: string;
+};
+
+// @public (undocumented)
+export function createFetchStreamTransport(request: HttpRequest, stream: StreamPort): TransportPort;
+
+// @public (undocumented)
+export function createHttpConversationSource(request: HttpRequest): ConversationSource;
+
+// @public (undocumented)
+export function createHttpTransport(request: HttpRequest, stream: StreamPort, format?: "sse" | "ndjson" | "signals"): TransportPort;
+
+// @public (undocumented)
+export function createMemoryStorage(asynchronous?: boolean): StoragePort;
+
+// @public (undocumented)
+export function createPlanRunner(ports: RunnerPorts): PlanRunner;
+
+// @public (undocumented)
+export function createSignalTransport(request: HttpRequest, stream: StreamPort): TransportPort;
+
+// @public (undocumented)
+export function createSseTransport(request: HttpRequest, stream: StreamPort): TransportPort;
+
+// @public (undocumented)
+export function createWaypointClient(config: ClientConfig): WaypointClient;
+
+// @public (undocumented)
+export interface DecisionVersions {
+    // (undocumented)
+    decisionResolution: number;
+    // (undocumented)
+    evidence: number;
+    // (undocumented)
+    winner: number;
+}
+
+// @public
+export function decodeFrames(chunks: AsyncIterable<string>, format: "sse" | "ndjson"): AsyncGenerator<Frame>;
+
+// @public (undocumented)
+export const DEFAULT_FLOW_TABS: readonly BuiltinFlowTab[];
+
+// @public (undocumented)
+export interface ExecutionAcceptance {
+    // (undocumented)
+    executionId: string;
+    // (undocumented)
+    fence: number;
+    // (undocumented)
+    planId: string;
+}
+
+// @public (undocumented)
+export interface ExtensionBlock {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: unknown;
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: string;
+}
+
+// @public
+export interface FeedbackInput extends MessageVersionInput {
+    rating: "positive" | "negative";
+}
+
+// @public
+export interface FeedbackPort {
+    send(input: FeedbackInput): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface FinalHistory {
+    contradictedAfterSeal?: string[];
+    // (undocumented)
+    keptFact: KeptFact;
+    // (undocumented)
+    relation?: 'keptElsewhere' | 'leaveCompletedByKeep' | 'leaveCoveredByKeep';
+    // (undocumented)
+    requestedTargetApplied?: boolean;
+    // (undocumented)
+    winner: IntentWinner;
+}
+
+// @public (undocumented)
+export type Flow = {
+    [k: string]: unknown;
+} & {
+    format: '1.0';
+    id: string;
+    title: string;
+    kind: 'structured' | 'prompt';
+    parameters: FlowParameter[];
+    steps?: {
+        operation: string;
+        arguments: {};
+    }[];
+    tags: string[];
+    body: string;
+};
+
+// @public (undocumented)
+export interface FlowParameter {
+    // (undocumented)
+    default?: unknown;
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    required: boolean;
+    // (undocumented)
+    type: 'string' | 'number' | 'boolean';
+}
+
+// @public (undocumented)
+export interface FlowSource {
+    // (undocumented)
+    list(tab: FlowTab): MaybePromise<FlowSummary[]>;
+    // (undocumented)
+    load?(id: string): MaybePromise<Flow>;
+    // (undocumented)
+    run(id: string, values: Record<string, unknown>, document?: Flow): MaybePromise<{
+        conversationId: string;
+        plan?: PlanRecord;
+    }>;
+    // (undocumented)
+    setFavourite(id: string, favourite: boolean): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface FlowSummary {
+    // (undocumented)
+    favourite?: boolean;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    lastRunAt?: number;
+    // (undocumented)
+    runCount?: number;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export type FlowTab = BuiltinFlowTab | {
+    id: string;
+    labelKey: string;
+};
+
+// @public (undocumented)
+export function flowTabId(tab: FlowTab): string;
+
+// @public
+export const FORM_SESSION_UNAVAILABLE: {
+    readonly code: "retryable";
+    readonly id: "form-session-load";
+};
+
+// @public (undocumented)
+export interface FormDraft {
+    // (undocumented)
+    edited: boolean;
+    // (undocumented)
+    label: string;
+    localInvalid?: true;
+    // (undocumented)
+    localText?: string;
+    // (undocumented)
+    replacement?: {
+        value: unknown;
+        validation: FormValidation;
+        revision: number;
+        fill?: string;
+    };
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    validation?: FormValidation;
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormField {
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    tier: "low" | "sensitive" | "human-only";
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormFillField {
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    tier: 'low';
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormFillRequest {
+    // (undocumented)
+    attachments: string[];
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    fields: [FormFillField, ...FormFillField[]];
+    // (undocumented)
+    references: string[];
+    // (undocumented)
+    requestId: string;
+    // (undocumented)
+    text: string;
+}
+
+// @public (undocumented)
+export interface FormFillValue {
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    validation: FormValidation;
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormMaterial {
+    // (undocumented)
+    attachments?: string[];
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    references?: string[];
+    // (undocumented)
+    text: string;
+}
+
+// @public (undocumented)
+export interface FormSession {
+    // (undocumented)
+    begin(material: FormMaterial): FormFillRequest;
+    // (undocumented)
+    cancel(): void;
+    // (undocumented)
+    cancelReplacement(field: string): void;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    edit(field: string, value: unknown): void;
+    failRequest(requestId: string): void;
+    // (undocumented)
+    getSnapshot(): FormSnapshot;
+    markEdited(field: string, text: string): void;
+    // (undocumented)
+    receive(body: unknown): boolean;
+    // (undocumented)
+    replace(field: string, revision: number): boolean;
+    revert(fill: string): boolean;
+    // (undocumented)
+    subscribe(listener: () => void): () => void;
+}
+
+// @public (undocumented)
+export interface FormSessionConfig {
+    // (undocumented)
+    fields: readonly FormField[];
+    // (undocumented)
+    ids(): string;
+}
+
+// @public (undocumented)
+export interface FormSnapshot {
+    // (undocumented)
+    fields: Readonly<Record<string, FormDraft>>;
+    fills?: readonly {
+        id: string;
+        fields: readonly string[];
+    }[];
+    // (undocumented)
+    pending: boolean;
+}
+
+// @public (undocumented)
+export type FormSubject = {
+    [k: string]: unknown;
+} & {
+    key: string;
+    resource: string;
+    label: string;
+    route: string;
+    state: 'pending' | 'bound' | 'unlinked';
+    record?: string;
+};
+
+// @public (undocumented)
+export interface FormValidation {
+    // (undocumented)
+    guidance?: string;
+    // (undocumented)
+    messages: string[];
+    // (undocumented)
+    status: 'valid' | 'invalid';
+}
+
+// @public (undocumented)
+export type Frame = FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem;
+
+// @public (undocumented)
+export interface FrameBlock {
+    // (undocumented)
+    block: Block;
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'block';
+}
+
+// @public (undocumented)
+export interface FrameMessageEnd {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    status: 'completed' | 'failed' | 'unavailable' | 'stopped';
+    // (undocumented)
+    type: 'message.end';
+}
+
+// @public (undocumented)
+export interface FrameMessageStart {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    role: 'user' | 'assistant';
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'message.start';
+}
+
+// @public (undocumented)
+export interface FramePlanDraft {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    plan: ImmediateDraft;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.draft';
+}
+
+// @public (undocumented)
+export interface FramePlanFinal {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    plan: ImmediatePlan | TimedPlan;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.final';
+}
+
+// @public (undocumented)
+export interface FramePlanningRead {
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    template: ReadTemplate;
+    // (undocumented)
+    type: 'planning-read';
+}
+
+// @public (undocumented)
+export interface FramePlanStep {
+    // (undocumented)
+    outcome: Outcome;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.step';
+}
+
+// @public (undocumented)
+export interface FrameProblem {
+    // (undocumented)
+    problem: Problem;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'problem';
+}
+
+// @public (undocumented)
+export interface FrameStale {
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    reads: ('conversation' | 'conversations' | 'plans' | 'flows')[];
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'stale';
+}
+
+// @public (undocumented)
+export interface FrameTextDelta {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    text: string;
+    // (undocumented)
+    type: 'text.delta';
+}
+
+// @public (undocumented)
+export interface FrameToolCall {
+    // (undocumented)
+    call: ToolCall;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'tool.call';
+}
+
+// @public
+export function handlePlanningRead(call: ReadTemplate, template: ReadTemplate, request: (call: ReadTemplate) => Promise<{
+    rows: Record<string, unknown>;
+    versions: Record<string, string>;
+}>): Promise<{
+    kind: "refused";
+    reason: string;
+} | {
+    kind: "plan.values";
+    rows: Record<string, Record<string, unknown>>;
+    versions: Record<string, string>;
+}>;
+
+// @public
+export function handleToolRead(call: ToolCall, manifest: readonly ManifestEntry[], request: (call: ToolCall) => Promise<unknown>): Promise<ReadResult>;
+
+// @public (undocumented)
+export interface HttpInit {
+    // (undocumented)
+    body?: string;
+    // (undocumented)
+    headers?: Record<string, string>;
+    // (undocumented)
+    method?: string;
+}
+
+// @public (undocumented)
+export type HttpRequest = (path: string, init?: HttpInit) => Promise<HttpResult>;
+
+// @public (undocumented)
+export interface HttpResult {
+    // (undocumented)
+    body: unknown;
+    // (undocumented)
+    status: number;
+}
+
+// @public (undocumented)
+export interface ImmediateDraft {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'immediate';
+    // (undocumented)
+    stage: 'draft';
+    // (undocumented)
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+}
+
+// @public (undocumented)
+export interface ImmediatePlan {
+    // (undocumented)
+    digest: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'immediate';
+    // (undocumented)
+    stage: 'final';
+    // (undocumented)
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+    // (undocumented)
+    stepUpCount: number;
+}
+
+// @public (undocumented)
+export type IntentAlert = {
+    serial: number;
+    action: "checkStatus" | "retry" | "signIn" | "hostGuidance" | "wait";
+} | {
+    serial: number;
+    restoreFocus: true;
+};
+
+// @public (undocumented)
+export type IntentCause = 'user' | 'connection-lost' | 'renewal-refused' | 'step-failed' | 'step-up-failed' | 'identity-lost' | 'attribution-missing' | 'plan-changed' | 'adapter-configuration';
+
+// @public (undocumented)
+export type IntentFailure = "offline" | "sign-in" | "forbidden" | "rate-limited" | "timeout" | "connection-lost";
+
+// @public (undocumented)
+export type IntentKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+
+// @public (undocumented)
+export type IntentNotice = Omit<PlanIntentReply, "slotVersion"> & {
+    resolvedSlotVersion: number;
+};
+
+// @public
+export interface IntentOverlay {
+    // (undocumented)
+    delivery: "sending" | "uncertain" | "not-sent";
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    lastProblem?: {
+        key: string;
+        cause: IntentFailure;
+    };
+    // (undocumented)
+    ownRun: boolean;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    producer: "user" | "automatic";
+    // (undocumented)
+    request: IntentRequest;
+    // (undocumented)
+    retryAt?: number;
+}
+
+// @public (undocumented)
+export interface IntentRequest {
+    // (undocumented)
+    acknowledgment?: LeaveAcknowledgment;
+    // (undocumented)
+    capturedRound: number;
+    // (undocumented)
+    cause: IntentCause;
+    // (undocumented)
+    correlation: string;
+    // (undocumented)
+    expectedSlotVersion: number;
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    payload?: string;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    review?: 'forward-only' | 'end-retention';
+    // (undocumented)
+    target: IntentTarget;
+}
+
+// @public (undocumented)
+export interface IntentTarget {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'generation' | 'review' | 'execution';
+}
+
+// @public (undocumented)
+export interface IntentWinner {
+    // (undocumented)
+    cause: IntentCause;
+    // (undocumented)
+    kind: WinnerKind;
+}
+
+// @public (undocumented)
+export interface KeepChangesReview {
+    // (undocumented)
+    acknowledgment: LeaveAcknowledgment;
+    // (undocumented)
+    remaining: number;
+    // (undocumented)
+    review: "forward-only" | "end-retention";
+}
+
+// @public (undocumented)
+export type KeepChangesReviewResult = KeepChangesReview | {
+    disabled: KeepDisabledReason;
+};
+
+// @public (undocumented)
+export type KeepDisabledReason = "loading" | "intentUnavailable" | "capabilityMissing" | "keepNoDecision" | "sealed" | "keepBlockedActive" | "keepBlockedUnknown";
+
+// @public (undocumented)
+export interface KeptFact {
+    // (undocumented)
+    actorCause: IntentCause;
+    // (undocumented)
+    keepEffect: 'forward-closed' | 'decision-closed' | 'retention-ended' | 'leave-completed';
+    // (undocumented)
+    round: number;
+}
+
+// @public (undocumented)
+export interface LeaveAcknowledgment {
+    // (undocumented)
+    decisionResolutionVersion: number;
+    // (undocumented)
+    evidenceDigest: string;
+    // (undocumented)
+    evidenceVersion: number;
+    // (undocumented)
+    sourceDecisionKey: string;
+    // (undocumented)
+    unknownCount: number;
+    // (undocumented)
+    winnerVersion: number;
+}
+
+// @public
+export function loadFormSession(config: FormSessionConfig): Promise<FormSession>;
+
+// @public
+export function loadReadHandlers(): Promise<void>;
+
+// @public (undocumented)
+export interface ManifestEntry {
+    // (undocumented)
+    fields: {
+        [k: string]: 'low' | 'sensitive' | 'human-only';
+    };
+    // (undocumented)
+    filterable: string[];
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'read' | 'planning-read' | 'update' | 'create' | 'action' | 'bulk';
+    // (undocumented)
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    permission: string;
+    // (undocumented)
+    resource: string;
+    // (undocumented)
+    returns: string[];
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    view: string;
+}
+
+// @public (undocumented)
+export type MaybePromise<T> = T | Promise<T>;
+
+// @public (undocumented)
+export interface Message {
+    // (undocumented)
+    blocks: Block[];
+    // (undocumented)
+    clientMessageId?: string;
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    createdAt: number;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    role: 'user' | 'assistant';
+    sources?: Source[];
+    // (undocumented)
+    status?: 'writing' | 'completed' | 'failed' | 'unavailable' | 'stopped';
+    // (undocumented)
+    versionCount?: number;
+    // (undocumented)
+    versionIndex?: number;
+}
+
+// @public (undocumented)
+export interface MessageVersionInput {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    messageId: string;
+}
+
+// @public (undocumented)
+export interface MessageVersionPort {
+    // (undocumented)
+    edit(input: MessageVersionInput & {
+        content: string;
+    }): MaybePromise<void>;
+    // (undocumented)
+    regenerate(input: MessageVersionInput): MaybePromise<void>;
+    // (undocumented)
+    select(input: MessageVersionInput & {
+        index: number;
+    }): MaybePromise<void>;
+}
+
+// @public
+export function negotiate(supported: readonly string[], capabilities?: readonly string[], offer?: NegotiationOffer): {
+    protocol: string;
+    capabilities: Capability[];
+};
+
+// @public (undocumented)
+export interface Negotiated {
+    // (undocumented)
+    agreementId?: string;
+    // (undocumented)
+    capabilities: string[];
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface Negotiation {
+    // (undocumented)
+    offer?: NegotiationOfferWire;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    supported: string[];
+}
+
+// @public
+export interface NegotiationOffer {
+    // (undocumented)
+    capabilities: readonly string[];
+}
+
+// @public (undocumented)
+export interface NegotiationOfferWire {
+    // (undocumented)
+    capabilities: string[];
+}
+
+// @public (undocumented)
+export interface Outcome {
+    // (undocumented)
+    attributed: boolean;
+    reason?: string;
+    retryable?: boolean;
+    // (undocumented)
+    status: number;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    version?: string;
+}
+
+// @public (undocumented)
+export function parseFlow(source: string, operations: readonly string[]): Promise<Flow>;
+
+// @public (undocumented)
+export interface PatchFlow {
+    // (undocumented)
+    favourite: boolean;
+    // (undocumented)
+    flowId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export interface PendingSend {
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    extensions?: Record<string, unknown>;
+    // (undocumented)
+    failure: Problem | null;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export type Plan = ImmediateDraft | ImmediatePlan | TimedPlan;
+
+// @public (undocumented)
+export interface PlanCommand {
+    // (undocumented)
+    action: 'stop' | 'heartbeat' | 'resume' | 'retry-undo';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface PlanIntentReply {
+    // (undocumented)
+    capturedRound: number;
+    // (undocumented)
+    correlation: string;
+    // (undocumented)
+    count?: number;
+    // (undocumented)
+    dispositionApplied?: boolean;
+    // (undocumented)
+    effectiveRound: number;
+    // (undocumented)
+    finalHistory?: FinalHistory;
+    // (undocumented)
+    forwardClosed?: boolean;
+    // (undocumented)
+    keys: string[];
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    phase: RecoveryPhase;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    replacement?: IntentTarget;
+    // (undocumented)
+    requestedTargetApplied?: boolean;
+    // (undocumented)
+    requestKey?: 'requestAlreadyStopped' | 'requestTargetStopped';
+    // (undocumented)
+    resolvedTarget?: string;
+    // (undocumented)
+    result: 'applied' | 'replaced' | 'already-closed' | 'already-stopped' | 'defeated' | 'superseded' | 'needs-review' | 'conflict' | 'unavailable' | 'invalid-target' | 'refused' | 'kept' | 'already-kept' | 'sealed';
+    // (undocumented)
+    safetyApplied?: boolean;
+    // (undocumented)
+    savedDisposition?: {
+        phase: 'left-known' | 'left-unconfirmed';
+        count: number;
+    };
+    // (undocumented)
+    slotVersion: number;
+    // (undocumented)
+    winner?: IntentWinner;
+}
+
+// @public
+export class PlanReadRefused extends Error {
+    constructor();
+}
+
+// @public (undocumented)
+export interface PlanRecord {
+    // (undocumented)
+    confirmation?: ConfirmationRecord;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    outcomes: Outcome[];
+    // (undocumented)
+    plan: Plan;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    reason?: string;
+    // (undocumented)
+    recovery?: RecoveryView;
+    // (undocumented)
+    state: PlanState;
+    // (undocumented)
+    undoPlanId?: string;
+}
+
+// @public (undocumented)
+export interface PlanRunner {
+    // (undocumented)
+    dispose(): void;
+    interrupt?(): void;
+    // (undocumented)
+    run(id: string, confirmedDigest: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    // (undocumented)
+    stop(id?: string): void;
+}
+
+// @public (undocumented)
+export type PlanState = 'proposed' | 'awaiting-confirmation' | 'running' | 'undoing' | 'completed' | 'submitted' | 'undone' | 'needs-attention' | 'cancelled';
+
+// @public (undocumented)
+export interface PlatformPorts {
+    // (undocumented)
+    clock: {
+        now(): number;
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    // (undocumented)
+    ids(): string;
+    // (undocumented)
+    online(): boolean;
+    subscribeOnline?(listener: (online: boolean) => void): () => void;
+    subscribeVisibility?(listener: (visible: boolean) => void): () => void;
+    // (undocumented)
+    visibility(): boolean;
+}
+
+// @public (undocumented)
+export interface Problem {
+    // (undocumented)
+    code: 'update-required' | 'in-doubt' | 'replaced' | 'retryable' | 'refused' | 'closed' | 'full' | 'declined' | 'unavailable' | 'sign-in' | 'rate-limited' | 'step-up-cancelled' | 'mismatch' | 'invalid-read' | 'invalid-plan' | 'needs-attention' | 'stopped' | 'plan-changed' | 'agreement-expired';
+    confirmation?: {
+        reason: 'expired' | 'used' | 'stale' | 'mismatch' | 'missing';
+    };
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    retryAfter?: number;
+}
+
+// @public
+export interface ReaderRequestContext {
+    // (undocumented)
+    agreementId: string;
+}
+
+// @public (undocumented)
+export interface ReadPorts {
+    // (undocumented)
+    manifest: readonly ManifestEntry[];
+    // (undocumented)
+    planning?: {
+        template(planId: string, stepId: string): MaybePromise<ReadTemplate | null>;
+        request(template: ReadTemplate): Promise<{
+            rows: Record<string, unknown>;
+            versions: Record<string, string>;
+        }>;
+    };
+    // (undocumented)
+    request(call: ToolCall): Promise<unknown>;
+}
+
+// @public
+export function readProblem(error: unknown, id: string): Problem;
+
+// @public (undocumented)
+export type ReadResult = {
+    kind: "refused";
+    reason: string;
+} | {
+    kind: "result";
+    callId: string;
+    result: unknown;
+};
+
+// @public (undocumented)
+export interface ReadTemplate {
+    // (undocumented)
+    fields: string[];
+    // (undocumented)
+    method: 'GET';
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    rows: string[];
+}
+
+// @public (undocumented)
+export type RecoveryPhase = 'proposal' | 'initial-review' | 'forward-active' | 'readback' | 'completed' | 'cancelled' | 'left-known' | 'left-unconfirmed' | 'left-reopened';
+
+// @public (undocumented)
+export interface RecoveryView {
+    contradictedAfterSeal?: string[];
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    decisionKey?: string;
+    // (undocumented)
+    evidenceDigest?: string;
+    // (undocumented)
+    executionId?: string;
+    // (undocumented)
+    generation: string;
+    // (undocumented)
+    phase: RecoveryPhase | (string & {});
+    // (undocumented)
+    profile: 'plan-recovery-v1' | (string & {});
+    // (undocumented)
+    remaining?: number;
+    // (undocumented)
+    reviewId?: string;
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    round: number;
+    // (undocumented)
+    sealed?: boolean;
+    // (undocumented)
+    slots: {
+        stop: number;
+        'cancel-initial': number;
+        'cancel-review': number;
+        leave: number;
+        keep: number;
+    };
+    // (undocumented)
+    steps?: {
+        stepId: string;
+        truth: 'done' | 'not-done' | 'unknown';
+    }[];
+    // (undocumented)
+    unknownCount?: number;
+    // (undocumented)
+    versions: DecisionVersions;
+    // (undocumented)
+    winner?: IntentWinner;
+}
+
+// @public (undocumented)
+export type Reply = ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | ReplyFormFill | ReplyStop;
+
+// @public (undocumented)
+export interface ReplyAction {
+    // (undocumented)
+    actionId: string;
+    // (undocumented)
+    blockId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'action';
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface ReplyConfirm {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    confirmationToken: string;
+    // (undocumented)
+    digest?: string;
+    // (undocumented)
+    kind: 'confirm';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface ReplyDecline {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'decline';
+    // (undocumented)
+    planId: string;
+}
+
+// @public
+export interface ReplyDelivery {
+    // (undocumented)
+    acceptance?: ExecutionAcceptance;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export interface ReplyForm {
+    // (undocumented)
+    blockId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'form';
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    values: {};
+}
+
+// @public (undocumented)
+export interface ReplyFormFill {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'form-fill';
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    request: FormFillRequest;
+}
+
+// @public (undocumented)
+export type ReplyInput = Reply extends infer R ? R extends {
+    protocol: string;
+} ? Omit<R, "protocol"> & {
+    protocol?: string;
+} : never : never;
+
+// @public (undocumented)
+export interface ReplyMessage {
+    // (undocumented)
+    clientMessageId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    kind: 'message';
+    // (undocumented)
+    protocol: string;
+}
+
+// @public
+export type ReplyOutcome = {
+    accepted: true;
+} | {
+    accepted: false;
+    problem?: Problem;
+};
+
+// @public (undocumented)
+export interface ReplyPlanValues {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'plan.values';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    steps: {
+        stepId: string;
+        rows: {};
+        versions: {
+            [k: string]: string;
+        };
+    }[];
+}
+
+// @public (undocumented)
+export function replyRow(input: {
+    messages: readonly Message[];
+    pending: readonly PendingSend[];
+    now: number;
+    askedAt?: number;
+    overdueAt?: number;
+    heldUntil?: number;
+    unavailable?: boolean;
+    failed?: boolean;
+    streamLost?: boolean;
+    activityAt?: number;
+}): ReplyState;
+
+// @public (undocumented)
+export type ReplyState = "none" | "writing" | "unavailable" | "failed" | "overdue";
+
+// @public
+export interface ReplyStop {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'stop';
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    versionIndex?: number;
+}
+
+// @public (undocumented)
+export interface ReplyToolResult {
+    // (undocumented)
+    callId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'tool-result';
+    // (undocumented)
+    problem?: Problem;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    result: unknown;
+}
+
+// @public (undocumented)
+export interface RestoredMessage {
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export function runConformance(config: ConformanceConfig): Promise<ConformanceResult>;
+
+// @public (undocumented)
+export interface RunFlow {
+    // (undocumented)
+    flowId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    values: {};
+}
+
+// @public (undocumented)
+export function runFormFillConformance(request: HttpRequest): Promise<ConformanceResult>;
+
+// @public (undocumented)
+export interface RunnerPorts {
+    // (undocumented)
+    clock?: PlatformPorts["clock"];
+    heartbeat(id: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    // (undocumented)
+    heartbeatMs?: number;
+    intent?(request: IntentRequest): Promise<PlanIntentReply>;
+    interrupted?(id: string, cause: IntentCause): Promise<void>;
+    // (undocumented)
+    onRecord?(record: PlanRecord): void;
+    read(id: string, context?: ReaderRequestContext): Promise<PlanRecord>;
+    // (undocumented)
+    request(request: CanonicalRequest, context: StepContext): Promise<void>;
+    signal?: ScopeSignal;
+    // (undocumented)
+    stepUp?(planId: string, stepId: string): Promise<string | null>;
+    // @deprecated (undocumented)
+    stop?(id: string): Promise<PlanRecord>;
+}
+
+// @public (undocumented)
+export function runPlanConformance(request: HttpRequest): Promise<ConformanceResult>;
+
+// @public (undocumented)
+export interface ScopeSignal {
+    // (undocumented)
+    readonly aborted: boolean;
+    // (undocumented)
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    // (undocumented)
+    removeEventListener(type: "abort", listener: () => void): void;
+}
+
+// @public (undocumented)
+export interface Source {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    title: string;
+    // (undocumented)
+    url: string;
+}
+
+// @public (undocumented)
+export interface Step {
+    // (undocumented)
+    after?: {};
+    // (undocumented)
+    before?: {};
+    // (undocumented)
+    fields: string[];
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    operation: string;
+    // (undocumented)
+    planningRead?: ReadTemplate;
+    // (undocumented)
+    request?: CanonicalRequest;
+    // (undocumented)
+    resource: string;
+    // (undocumented)
+    rows: string[];
+    // (undocumented)
+    stepUp: boolean;
+    // (undocumented)
+    tier: 'low' | 'sensitive';
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    view: string;
+}
+
+// @public (undocumented)
+export interface StepContext {
+    // (undocumented)
+    headers: Record<string, string>;
+    // (undocumented)
+    planId: string;
+    signal?: ScopeSignal;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    stepUpCode?: string;
+}
+
+// @public (undocumented)
+export interface StoragePort {
+    compareAndSet?(key: string, expected: string | null, value: string): MaybePromise<boolean>;
+    // (undocumented)
+    get(key: string): MaybePromise<string | null>;
+    // (undocumented)
+    remove(key: string): MaybePromise<void>;
+    // (undocumented)
+    set(key: string, value: string): MaybePromise<void>;
+}
+
+// @public
+export const STREAM_READS_UNAVAILABLE: {
+    readonly code: "retryable";
+    readonly id: "stream-reads-load";
+};
+
+// @public (undocumented)
+export interface StreamPort {
+    // (undocumented)
+    subscribe(path: string, onChunk: (chunk: string) => void, onStatus: (status: "connecting" | "open" | "reconnecting" | "unavailable") => void): () => void;
+}
+
+// @public (undocumented)
+export const SUPPORTED_PROTOCOLS: readonly ["1.1", "1.0"];
+
+// @public (undocumented)
+export interface TimedPlan {
+    // (undocumented)
+    end: string | null;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'timed';
+    // (undocumented)
+    start: string | null;
+    // (undocumented)
+    values: {
+        [k: string]: {
+            [k: string]: unknown;
+        };
+    };
+}
+
+// @public (undocumented)
+export interface ToolCall {
+    // (undocumented)
+    id: string;
+    label?: string;
+    // (undocumented)
+    method: string;
+    // (undocumented)
+    operation: string;
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    query?: {
+        [k: string]: string;
+    };
+}
+
+// @public
+export interface ToolStep {
+    // (undocumented)
+    id: string;
+    label?: string;
+    // (undocumented)
+    status: "running" | "done" | "failed";
+}
+
+// @public (undocumented)
+export type TransportEvent = {
+    type: "status";
+    status: "connecting" | "open" | "reconnecting" | "unavailable";
+} | {
+    type: "frame";
+    frame: Frame;
+}
+/** A hint that the conversation changed; it is never applied as content. */
+| {
+    type: "invalidate";
+};
+
+// @public (undocumented)
+export type TransportListener = (event: TransportEvent) => void;
+
+// @public (undocumented)
+export interface TransportPort {
+    negotiate(supported: readonly string[], offer?: NegotiationOffer): Promise<{
+        protocol: string;
+        capabilities: string[];
+        agreementId?: string;
+    }>;
+    // (undocumented)
+    read(conversationId: string, context?: ReaderRequestContext): Promise<Conversation>;
+    // (undocumented)
+    send(reply: Reply & {
+        extensions?: Record<string, unknown>;
+    }, conversationId: string, context?: ReaderRequestContext): Promise<ReplyDelivery>;
+    // (undocumented)
+    subscribe(conversationId: string, listener: (event: TransportEvent) => void, context?: ReaderRequestContext): () => void;
+}
+
+// @public (undocumented)
+export function validateFlowDocument(value: unknown, operations: readonly string[]): Flow;
+
+// @public (undocumented)
+export function versionWalk(message: {
+    versionIndex?: number | null;
+    versionCount?: number | null;
+}): {
+    index: number;
+    count: number;
+    previous: number | null;
+    next: number | null;
+} | null;
+
+// @public (undocumented)
+export interface WaypointClient {
+    canChangeVersions(): boolean;
+    // (undocumented)
+    canKeepChanges(id?: string): boolean;
+    canPrepareFlow(): boolean;
+    canRetryReply(): boolean;
+    canSendFeedback(): boolean;
+    canStopReply(): boolean;
+    checkIntentStatus(id?: string): Promise<void>;
+    checkKeepStatus(id?: string): Promise<void>;
+    checkSavedChoice(id?: string): Promise<void>;
+    // (undocumented)
+    confirmPlan(): Promise<void>;
+    declinePlan(): Promise<void>;
+    discardRestored(id: string): Promise<void>;
+    // (undocumented)
+    dismiss(id: string): Promise<void>;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    editMessage(messageId: string, content: string): Promise<void>;
+    editRestored(id: string): Promise<void>;
+    // (undocumented)
+    getSnapshot(): ClientSnapshot;
+    keepChanges(review: KeepChangesReviewResult): Promise<void>;
+    keepChangesReview(id?: string): KeepChangesReviewResult;
+    keepWaiting(): void;
+    leavePlan(id?: string): Promise<void>;
+    // (undocumented)
+    loadFlows(): Promise<void>;
+    // (undocumented)
+    on(listener: (event: WaypointEvent) => void): () => void;
+    prepareFlow(id?: string): Promise<Flow | void>;
+    readPlan(id?: string): Promise<void>;
+    // (undocumented)
+    ready: Promise<void>;
+    // (undocumented)
+    refresh(): Promise<ConversationReadResult>;
+    // (undocumented)
+    regenerate(messageId: string): Promise<void>;
+    // (undocumented)
+    reply(reply: ReplyInput): Promise<boolean>;
+    replyOutcome(reply: ReplyInput): Promise<ReplyOutcome>;
+    // (undocumented)
+    report(problem: Problem): void;
+    // (undocumented)
+    resumePlan(): Promise<void>;
+    // (undocumented)
+    retry(id: string): Promise<void>;
+    // (undocumented)
+    retryIntent(id?: string): Promise<void>;
+    retryReply(): Promise<void>;
+    // (undocumented)
+    retryUndo(): Promise<void>;
+    runFlow(id: string, values: Record<string, unknown>): Promise<string | void>;
+    // (undocumented)
+    runPlan(id: string, confirmedDigest: string): Promise<void>;
+    // (undocumented)
+    selectFlowTab(tab: FlowTab): void;
+    // (undocumented)
+    selectVersion(messageId: string, index: number): Promise<void>;
+    // (undocumented)
+    send(): Promise<void>;
+    sendFeedback(messageId: string, rating: FeedbackInput["rating"]): Promise<boolean>;
+    // (undocumented)
+    setDraft(value: string): Promise<void>;
+    // (undocumented)
+    setFavourite(id: string, favourite: boolean): Promise<void>;
+    // (undocumented)
+    setPlan(plan: PlanRecord): void;
+    // (undocumented)
+    stopPlan(id?: string): void;
+    stopReply(): Promise<void>;
+    // (undocumented)
+    subscribe(listener: () => void): () => void;
+    // (undocumented)
+    switchConversation(id: string): Promise<ConversationReadResult>;
+    // (undocumented)
+    withdraw(id: string): Promise<void>;
+}
+
+// @public (undocumented)
+export type WaypointEvent = {
+    type: "send" | "reply";
+    conversationId: string;
+    replyId: string;
+} | {
+    type: "plan.state";
+    planId: string;
+} | {
+    type: "problem";
+    problemId: string;
+} | {
+    type: "transport.status";
+    conversationId: string;
+};
+
+// @public (undocumented)
+export type WaypointProtocol = Problem | Negotiation | NegotiationOfferWire | Negotiated | CanonicalRequest | ReadTemplate | Step | ImmediateDraft | ImmediatePlan | TimedPlan | Plan | PlanState | Outcome | ConfirmationItem | ConfirmationSchedule | ConfirmationRecord | PlanRecord | RecoveryPhase | IntentKind | WinnerKind | IntentCause | IntentWinner | RecoveryView | IntentTarget | IntentRequest | PlanIntentReply | ExecutionAcceptance | ReplyDecline | CardAnswer | BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | ExtensionBlock | Block | Message | Source | Conversation | ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | Reply | ReplyStop | ManifestEntry | ToolCall | FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem | Frame | FlowParameter | Flow | CreateConversation | PlanCommand | RunFlow | PatchFlow | FormSubject | FormValidation | FormFillValue | FormFillField | FormFillRequest | BlockFormFill | ReplyFormFill | LeaveAcknowledgment | DecisionVersions | KeptFact | FinalHistory;
+
+// @public (undocumented)
+export type WinnerKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+
+// @public
+export function withPrerequisites(chosen: Capability[]): Capability[];
+
+// (No @packageDocumentation comment for this package)
+
+```