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

package/dist/form-fill-Dp3ut1_Y.d.ts

@@ -0,0 +1,653 @@
+import { ac as PlanRecord, C as CanonicalRequest, E as ExecutionAcceptance, Y as IntentCause, _ as IntentRequest, ab as PlanIntentReply, ad as PlanState, M as ManifestEntry, T as ToolCall, R as ReadTemplate, s as Conversation, ag as Reply, F as Frame, a as Flow, P as Problem, a2 as LeaveAcknowledgment, q as ConfirmationRecord, a3 as Message, G as FormValidation, y as FormFillRequest, A as FormSubject, t as CreateConversation } from './generated-C9tbjwK0.js';
+import { a as ScopeSignal, d as IntentOverlay, c as IntentNotice, I as IntentAlert } from './intent-BuvqEU3Q.js';
+
+interface StepContext {
+    planId: string;
+    stepId: string;
+    headers: Record<string, string>;
+    stepUpCode?: string;
+    /**
+     * Aborted when the run is retired, stopped by dispose or interrupted; an
+     * adapter may pass it to its request. It is a standard AbortSignal.
+     */
+    signal?: ScopeSignal;
+}
+interface RunnerPorts {
+    /** `context` carries the client's current agreement when one exists. */
+    read(id: string, context?: ReaderRequestContext): Promise<PlanRecord>;
+    request(request: CanonicalRequest, context: StepContext): Promise<void>;
+    /** `acceptance` is the accepted execution's identity, when one exists. */
+    heartbeat(id: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    /**
+     * @deprecated The runner never asks the host to stop or undo a plan: a
+     * stopped or interrupted run only stops dispatching and reads its facts.
+     */
+    stop?(id: string): Promise<PlanRecord>;
+    /**
+     * Called once when a run is interrupted by a failure, with its cause,
+     * before the runner reads every step again. A client submits its Stop
+     * intent here; legacy runs leave it unset.
+     */
+    interrupted?(id: string, cause: IntentCause): Promise<void>;
+    /**
+     * Delivers a terminal intent (Stop or Cancel) for a protected plan through
+     * the host's safety-control route. A client offers `plan-recovery` only
+     * when this is present.
+     */
+    intent?(request: IntentRequest): Promise<PlanIntentReply>;
+    stepUp?(planId: string, stepId: string): Promise<string | null>;
+    clock?: PlatformPorts["clock"];
+    /** Aborting it disposes the runner, as `dispose()` does. */
+    signal?: ScopeSignal;
+    heartbeatMs?: number;
+    onRecord?(record: PlanRecord): void;
+}
+interface PlanRunner {
+    run(id: string, confirmedDigest: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    stop(id?: string): void;
+    /**
+     * Retires the active invocation locally: it dispatches nothing more and
+     * keeps no step-up code, and no remote stop or undo is requested. A later
+     * explicit run starts a fresh invocation.
+     */
+    interrupt?(): void;
+    dispose(): void;
+}
+/**
+ * Thrown by a plan port's read when the client's record gate refused the
+ * record; the run ends as an interruption with cause `plan-changed`.
+ */
+declare class PlanReadRefused extends Error {
+    constructor();
+}
+declare function canTransition(from: PlanState, to: PlanState): boolean;
+declare function createPlanRunner(ports: RunnerPorts): PlanRunner;
+
+declare const SUPPORTED_PROTOCOLS: readonly ["1.1", "1.0"];
+declare const CAPABILITIES: readonly ["plans", "flows", "widgets", "step-up", "scheduled", "form-fill", "plan-recovery", "plan-leave", "plan-keep", "reply-stop"];
+type Capability = (typeof CAPABILITIES)[number];
+/** Drops a capability whose prerequisite is not also in `chosen`. */
+declare function withPrerequisites(chosen: Capability[]): Capability[];
+/** What a client offers when it negotiates: the capabilities it implements. */
+interface NegotiationOffer {
+    capabilities: readonly string[];
+}
+/**
+ * Picks the protocol and capabilities for a negotiation. A host that passes
+ * the client's `offer` gets only capabilities both sides support; a host that
+ * passes two arguments keeps the legacy server-only list and issues no
+ * agreement.
+ */
+declare function negotiate(supported: readonly string[], capabilities?: readonly string[], offer?: NegotiationOffer): {
+    protocol: string;
+    capabilities: Capability[];
+};
+declare function blockFallback(block: {
+    type: string;
+    id?: string;
+    fallback: string;
+}): {
+    text: string;
+    disabled: true;
+    update: true;
+};
+
+type MaybePromise<T> = T | Promise<T>;
+type KeepDisabledReason = "loading" | "intentUnavailable" | "capabilityMissing" | "keepNoDecision" | "sealed" | "keepBlockedActive" | "keepBlockedUnknown";
+interface KeepChangesReview {
+    review: "forward-only" | "end-retention";
+    remaining: number;
+    acknowledgment: LeaveAcknowledgment;
+}
+type KeepChangesReviewResult = KeepChangesReview | {
+    disabled: KeepDisabledReason;
+};
+interface StoragePort {
+    get(key: string): MaybePromise<string | null>;
+    set(key: string, value: string): MaybePromise<void>;
+    remove(key: string): MaybePromise<void>;
+    /**
+     * Optional atomic commit: writes `value` only if the stored value is still
+     * `expected` (null for absent), and reports whether it wrote. Stores shared
+     * by several runtimes should implement it; see `commitRecord`.
+     */
+    compareAndSet?(key: string, expected: string | null, value: string): MaybePromise<boolean>;
+}
+interface PlatformPorts {
+    clock: {
+        now(): number;
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    online(): boolean;
+    visibility(): boolean;
+    ids(): string;
+    /**
+     * Optional notification of connectivity changes. The client retries a failed
+     * startup when it reports `true`, and unsubscribes on dispose. Without it the
+     * client falls back to its retry timer and the `online()` boolean.
+     */
+    subscribeOnline?(listener: (online: boolean) => void): () => void;
+    /**
+     * Optional notification of visibility changes. The client retries a failed
+     * startup when the view becomes visible, and unsubscribes on dispose.
+     */
+    subscribeVisibility?(listener: (visible: boolean) => void): () => void;
+}
+/**
+ * The binding a client sends with each request once the host issued an
+ * agreement. It identifies the negotiated answer; it is never authority.
+ */
+interface ReaderRequestContext {
+    agreementId: string;
+}
+/**
+ * What a host returns for a delivered reply. A first accepting confirmation
+ * of a protected plan also carries the private acceptance, which only the
+ * runner receives; public `reply` stays a boolean.
+ */
+interface ReplyDelivery {
+    id: string;
+    acceptance?: ExecutionAcceptance;
+}
+interface TransportPort {
+    /**
+     * Negotiates without storing any binding: each client owns its answer, even
+     * when several clients share one transport.
+     */
+    negotiate(supported: readonly string[], offer?: NegotiationOffer): Promise<{
+        protocol: string;
+        capabilities: string[];
+        agreementId?: string;
+    }>;
+    read(conversationId: string, context?: ReaderRequestContext): Promise<Conversation>;
+    send(reply: Reply & {
+        extensions?: Record<string, unknown>;
+    }, conversationId: string, context?: ReaderRequestContext): Promise<ReplyDelivery>;
+    subscribe(conversationId: string, listener: (event: TransportEvent) => void, context?: ReaderRequestContext): () => void;
+}
+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";
+};
+type WaypointEvent = {
+    type: "send" | "reply";
+    conversationId: string;
+    replyId: string;
+} | {
+    type: "plan.state";
+    planId: string;
+} | {
+    type: "problem";
+    problemId: string;
+} | {
+    type: "transport.status";
+    conversationId: string;
+};
+interface ComposerContribution {
+    id: string;
+    evaluate(context: {
+        draft: string;
+        conversationId: string;
+    }): MaybePromise<{
+        hold?: string;
+        hint?: string;
+        payload?: unknown;
+    }>;
+}
+interface MessageVersionInput {
+    conversationId: string;
+    messageId: string;
+    clientReplyId: string;
+}
+interface MessageVersionPort {
+    edit(input: MessageVersionInput & {
+        content: string;
+    }): MaybePromise<void>;
+    regenerate(input: MessageVersionInput): MaybePromise<void>;
+    select(input: MessageVersionInput & {
+        index: number;
+    }): MaybePromise<void>;
+}
+/** The user's rating of a reply, with the reply it rates. */
+interface FeedbackInput extends MessageVersionInput {
+    /** Good response (`positive`) or Bad response (`negative`). */
+    rating: "positive" | "negative";
+}
+/** Where a host takes the user's rating of a reply. */
+interface FeedbackPort {
+    /**
+     * Records a rating. The same rating of the same reply is not sent again
+     * while one is in flight, and each call has a new `clientReplyId`; a
+     * throw is reported as the press's problem.
+     */
+    send(input: FeedbackInput): MaybePromise<void>;
+}
+interface FlowSource {
+    load?(id: string): MaybePromise<Flow>;
+    list(tab: FlowTab): MaybePromise<FlowSummary[]>;
+    setFavourite(id: string, favourite: boolean): MaybePromise<void>;
+    run(id: string, values: Record<string, unknown>, document?: Flow): MaybePromise<{
+        conversationId: string;
+        plan?: PlanRecord;
+    }>;
+}
+type BuiltinFlowTab = "favourites" | "most-used" | "recent" | "presets";
+type FlowTab = BuiltinFlowTab | {
+    id: string;
+    labelKey: string;
+};
+declare const DEFAULT_FLOW_TABS: readonly BuiltinFlowTab[];
+declare function flowTabId(tab: FlowTab): string;
+interface FlowSummary {
+    id: string;
+    title: string;
+    favourite?: boolean;
+    runCount?: number;
+    lastRunAt?: number;
+}
+interface PendingSend {
+    id: string;
+    content: string;
+    failure: Problem | null;
+    extensions?: Record<string, unknown>;
+}
+type ReplyState = "none" | "writing" | "unavailable" | "failed" | "overdue";
+interface ClientSnapshot {
+    protocol: string | null;
+    replyState: ReplyState;
+    conversationId: string;
+    conversation: Conversation | null;
+    conversationUnavailable: boolean;
+    draft: string;
+    pending: readonly PendingSend[];
+    problem: Problem | null;
+    announcement: number;
+    observerFailures: number;
+    capabilities: readonly Capability[];
+    status: string;
+    plan: PlanRecord | null;
+    flows: Partial<Record<string, FlowSummary[]>>;
+    flowTab: string;
+    flowTabs: readonly FlowTab[];
+    hints: readonly string[];
+    sending: boolean;
+    /** The stream gave up after its bounded reopen attempts; `refresh()` retries. */
+    streamUnavailable: boolean;
+    /**
+     * The latest confirmation attempt that was not accepted: its token and its
+     * reply id. The current problem is that attempt's refusal only when its
+     * id is this reply id.
+     */
+    confirmationRefusal?: {
+        token: string;
+        problemId: string;
+    };
+    /** Queued messages whose withdrawal is waiting for its commit. */
+    withdrawing: readonly string[];
+    /**
+     * The reads the host asked for since the user's last message, in order,
+     * each running, done or failed.
+     */
+    toolSteps: readonly ToolStep[];
+    /** Withdrawn messages, kept apart from the draft until discarded. */
+    restored: readonly RestoredMessage[];
+    /** Pending terminal intents of protected plans, by plan id. */
+    intentOverlays: Readonly<Record<string, IntentOverlay>>;
+    /** The facts of the last resolved intent, as its reply gave them. */
+    intentNotice: IntentNotice | null;
+    intentAlert: IntentAlert | null;
+    /**
+     * The shown plan is protected but this client cannot control it now (a
+     * profile, phase or agreement it lacks, or a fresh read still due after
+     * a new agreement): it is shown, and nothing can be done with it here.
+     */
+    planReadOnly?: boolean;
+}
+/** A read the host asked for while writing a reply, as the user sees it. */
+interface ToolStep {
+    id: string;
+    /** The host's plain words for it (`ToolCall.label`), when it gave any. */
+    label?: string;
+    status: "running" | "done" | "failed";
+}
+interface RestoredMessage {
+    id: string;
+    content: string;
+}
+interface ReadPorts {
+    manifest: readonly ManifestEntry[];
+    request(call: ToolCall): Promise<unknown>;
+    planning?: {
+        template(planId: string, stepId: string): MaybePromise<ReadTemplate | null>;
+        request(template: ReadTemplate): Promise<{
+            rows: Record<string, unknown>;
+            versions: Record<string, string>;
+        }>;
+    };
+}
+interface ClientConfig {
+    formSession?: FormSession;
+    reads?: ReadPorts;
+    versions?: MessageVersionPort;
+    feedback?: FeedbackPort;
+    plans?: RunnerPorts & {
+        resume?(id: string): Promise<PlanRecord>;
+        retryUndo?(id: string): Promise<PlanRecord>;
+    };
+    accountId: string;
+    conversationId: string;
+    platform: PlatformPorts;
+    transport: TransportPort;
+    storage?: StoragePort;
+    beforeSend?: (reply: Reply) => MaybePromise<Reply | false | void>;
+    contributions?: readonly ComposerContribution[];
+    flowSource?: FlowSource;
+    flowOperations?: readonly string[];
+    tabs?: readonly FlowTab[];
+}
+type ReplyInput = Reply extends infer R ? R extends {
+    protocol: string;
+} ? Omit<R, "protocol"> & {
+    protocol?: string;
+} : never : never;
+/** How a reply ended: accepted, or not, and why when something was sent. */
+type ReplyOutcome = {
+    accepted: true;
+} | {
+    accepted: false;
+    problem?: Problem;
+};
+declare class ConversationReadError extends Error {
+    readonly conversationId: string;
+    readonly status: number;
+    /** A validated typed problem from the response, without any raw body. */
+    readonly problem?: Problem;
+    constructor(conversationId: string, status: number, problem?: unknown);
+}
+type ConversationReadResult = {
+    kind: "loaded";
+    conversationId: string;
+    conversation: Conversation;
+} | {
+    kind: "missing";
+    conversationId: string;
+    status: 404 | 410;
+} | {
+    kind: "unavailable" | "superseded";
+    conversationId: string;
+};
+interface WaypointClient {
+    ready: Promise<void>;
+    getSnapshot(): ClientSnapshot;
+    subscribe(listener: () => void): () => void;
+    on(listener: (event: WaypointEvent) => void): () => void;
+    setDraft(value: string): Promise<void>;
+    editMessage(messageId: string, content: string): Promise<void>;
+    regenerate(messageId: string): Promise<void>;
+    selectVersion(messageId: string, index: number): Promise<void>;
+    /** Whether a `versions` port can edit, regenerate and select versions. */
+    canChangeVersions(): boolean;
+    /** Whether a `feedback` port takes ratings of replies. */
+    canSendFeedback(): boolean;
+    /**
+     * Rates a finished reply through the `feedback` port, once per rating
+     * while it is in flight, and resolves with whether the port took it.
+     */
+    sendFeedback(messageId: string, rating: FeedbackInput["rating"]): Promise<boolean>;
+    send(): Promise<void>;
+    retry(id: string): Promise<void>;
+    withdraw(id: string): Promise<void>;
+    /** Appends a withdrawn message's content to the draft; the item stays. */
+    editRestored(id: string): Promise<void>;
+    /** Deletes a withdrawn message. */
+    discardRestored(id: string): Promise<void>;
+    dismiss(id: string): Promise<void>;
+    reply(reply: ReplyInput): Promise<boolean>;
+    /**
+     * Sends a reply and says how it ended: accepted, or not, with the problem
+     * the host or the network gave (none when nothing was sent). Resolves
+     * after the conversation was read again, so a card shows what the host
+     * holds.
+     */
+    replyOutcome(reply: ReplyInput): Promise<ReplyOutcome>;
+    refresh(): Promise<ConversationReadResult>;
+    switchConversation(id: string): Promise<ConversationReadResult>;
+    report(problem: Problem): void;
+    setPlan(plan: PlanRecord): void;
+    confirmPlan(): Promise<void>;
+    runPlan(id: string, confirmedDigest: string): Promise<void>;
+    stopPlan(id?: string): void;
+    /**
+     * Declines a protected plan's initial review: an initial Cancel through
+     * the intent port, never the normal replies route.
+     */
+    declinePlan(): Promise<void>;
+    /**
+     * Leaves a protected plan's decision: a Leave through the intent port,
+     * acknowledging the evidence and versions of the adopted record.
+     */
+    leavePlan(id?: string): Promise<void>;
+    /**
+     * Redelivers a protected plan's pending intent exactly as it was first
+     * built (status and Retry are one action): the host returns the stored
+     * outcome if it applied, or applies it once.
+     */
+    checkIntentStatus(id?: string): Promise<void>;
+    /** The same action as `checkIntentStatus`, named for Leave. */
+    checkSavedChoice(id?: string): Promise<void>;
+    /** The same action as `checkIntentStatus`, named for Keep. */
+    checkKeepStatus(id?: string): Promise<void>;
+    retryIntent(id?: string): Promise<void>;
+    /**
+     * What "Keep these changes" would confirm for a protected plan, read
+     * synchronously from the adopted record, or why it is not possible.
+     */
+    keepChangesReview(id?: string): KeepChangesReviewResult;
+    canKeepChanges(id?: string): boolean;
+    /** Sends exactly the Keep a review returned by `keepChangesReview`. */
+    keepChanges(review: KeepChangesReviewResult): Promise<void>;
+    resumePlan(): Promise<void>;
+    retryUndo(): Promise<void>;
+    /** Reads the plan's record from the host again and shows it. */
+    readPlan(id?: string): Promise<void>;
+    loadFlows(): Promise<void>;
+    selectFlowTab(tab: FlowTab): void;
+    setFavourite(id: string, favourite: boolean): Promise<void>;
+    /**
+     * Runs a flow; resolves with the conversation this run opened when its
+     * own navigation succeeded and is still shown, otherwise with nothing.
+     */
+    runFlow(id: string, values: Record<string, unknown>): Promise<string | void>;
+    /** Whether `prepareFlow` can read a flow's document (the source has `load`). */
+    canPrepareFlow(): boolean;
+    /** Whether the reply being written can be stopped (`reply-stop`). */
+    canStopReply(): boolean;
+    /**
+     * Stops the reply being written: its text so far stays, marked
+     * `stopped` at once, and the host is asked once to stop writing it. Text
+     * that still arrives for it is dropped. Does nothing without `reply-stop`.
+     */
+    stopReply(): Promise<void>;
+    /**
+     * Waits again for an overdue reply: the reply row says `writing` and
+     * turns overdue again only after another 15 seconds without progress.
+     */
+    keepWaiting(): void;
+    /**
+     * Waits again and reads the conversation again (`refresh()`). A failed
+     * reply is asked for again instead (`regenerate`) when a `versions` port
+     * is given: a new version, with the failed one kept. A reply the host
+     * ended as `failed` or `unavailable` is only ever asked for again: without
+     * a `versions` port a read would show it unchanged, so this does nothing
+     * (see `canRetryReply()`).
+     */
+    retryReply(): Promise<void>;
+    /**
+     * Whether `retryReply()` can do anything for the reply row's state: false
+     * only for a reply the host ended as `failed` or `unavailable` when no
+     * `versions` port is given.
+     */
+    canRetryReply(): boolean;
+    /**
+     * Loads and validates a flow's document, to ask for its parameters, and
+     * keeps it for the next `runFlow` of that flow in this conversation (a
+     * failed run keeps it for a retry); without an id, forgets it. Resolves
+     * with nothing when the source cannot load documents or without an id
+     * (also when the client actions' code cannot load, which reports the
+     * retryable `on-demand-load` problem). Rejects with what `load` or the
+     * document's validation threw, and with `{ code: "refused", id:
+     * "flow-prepare" }` when the conversation changed or a later
+     * preparation (or forgetting) superseded this one: nothing is kept then.
+     */
+    prepareFlow(id?: string): Promise<Flow | void>;
+    dispose(): void;
+}
+declare function createMemoryStorage(asynchronous?: boolean): StoragePort;
+declare function createWaypointClient(config: ClientConfig): WaypointClient;
+declare function asProblem(error: unknown, id: string): Problem;
+/** A failed read's problem: a host's whole-second wait makes it a rate limit. */
+declare function readProblem(error: unknown, id: string): Problem;
+/**
+ * The plan's confirmation record, when it is bound to this plan, this
+ * conversation and the plan's host revision. A record without a whole
+ * revision is never a match; a legacy plan record has no revision of its
+ * own to compare, so its host refuses a stale token.
+ */
+declare function confirmationOf(plan: PlanRecord | null | undefined, conversationId: string | undefined): ConfirmationRecord | undefined;
+declare function replyRow(input: {
+    messages: readonly Message[];
+    pending: readonly PendingSend[];
+    now: number;
+    askedAt?: number;
+    overdueAt?: number;
+    heldUntil?: number;
+    unavailable?: boolean;
+    failed?: boolean;
+    /** The stream that would carry the rest of the reply gave up. */
+    streamLost?: boolean;
+    /**
+     * When the reply being written last made progress, on the caller's clock.
+     * Without it the stall is not measured: the reply stays `writing`.
+     */
+    activityAt?: number;
+}): ReplyState;
+declare function versionWalk(message: {
+    versionIndex?: number | null;
+    versionCount?: number | null;
+}): {
+    index: number;
+    count: number;
+    previous: number | null;
+    next: number | null;
+} | null;
+interface AttachmentPort {
+    upload(data: Uint8Array, context: {
+        conversationId: string;
+        fileName: string;
+        contentType: string;
+    }): MaybePromise<{
+        id: string;
+    }>;
+    remove(id: string): MaybePromise<void>;
+}
+
+interface FormField {
+    name: string;
+    label: string;
+    tier: "low" | "sensitive" | "human-only";
+    value: unknown;
+}
+interface FormDraft {
+    label: string;
+    value: unknown;
+    revision: number;
+    edited: boolean;
+    validation?: FormValidation;
+    replacement?: {
+        value: unknown;
+        validation: FormValidation;
+        revision: number;
+        /** The fill that suggested it. */
+        fill?: string;
+    };
+    /**
+     * The user's entry does not parse as the field's type yet (`localText`
+     * holds it); `value` is still the last valid one. A host's own submit
+     * should refuse while it is set.
+     */
+    localInvalid?: true;
+    localText?: string;
+}
+interface FormSnapshot {
+    pending: boolean;
+    fields: Readonly<Record<string, FormDraft>>;
+    /** Applied fills that still own at least one field, oldest first. */
+    fills?: readonly {
+        id: string;
+        fields: readonly string[];
+    }[];
+}
+interface FormSession {
+    getSnapshot(): FormSnapshot;
+    subscribe(listener: () => void): () => void;
+    begin(material: FormMaterial): FormFillRequest;
+    receive(body: unknown): boolean;
+    edit(field: string, value: unknown): void;
+    replace(field: string, revision: number): boolean;
+    cancelReplacement(field: string): void;
+    /** Records an entry that does not parse yet: an edit that keeps `value`. */
+    markEdited(field: string, text: string): void;
+    /**
+     * Takes back a fill: each field it still owns gets its value and
+     * validation from before the fill, and its suggestions are withdrawn.
+     * Refused while a request is pending.
+     */
+    revert(fill: string): boolean;
+    /** Ends the pending request when its draft cannot be used. */
+    failRequest(requestId: string): void;
+    cancel(): void;
+    dispose(): void;
+}
+interface FormMaterial {
+    text: string;
+    references?: string[];
+    attachments?: string[];
+    field?: string;
+}
+interface ConversationSource {
+    list(subjectKey?: string): MaybePromise<ConversationSummary[]>;
+    create(input: CreateConversation): MaybePromise<Conversation>;
+}
+interface ConversationSummary {
+    id: string;
+    title: string;
+    mode?: "form-fill";
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+}
+interface FormSessionConfig {
+    fields: readonly FormField[];
+    ids(): string;
+}
+/** The problem a failed load of the form session code rejects with. */
+declare const FORM_SESSION_UNAVAILABLE: {
+    readonly code: "retryable";
+    readonly id: "form-session-load";
+};
+/**
+ * Creates a form session. Its code is loaded on first use, outside the core
+ * bundle. If loading fails the promise rejects with
+ * `FORM_SESSION_UNAVAILABLE`, nothing is kept, and calling again retries.
+ */
+declare function loadFormSession(config: FormSessionConfig): Promise<FormSession>;
+
+export { createMemoryStorage as $, type AttachmentPort as A, type BuiltinFlowTab as B, type ClientConfig as C, DEFAULT_FLOW_TABS as D, type MessageVersionPort as E, type FormSessionConfig as F, PlanReadRefused as G, type PlanRunner as H, type PlatformPorts as I, type ReaderRequestContext as J, type KeepChangesReview as K, type ReplyOutcome as L, type MaybePromise as M, type NegotiationOffer as N, type RestoredMessage as O, type PendingSend as P, type RunnerPorts as Q, type ReplyInput as R, type StepContext as S, type StoragePort as T, type ToolStep as U, type TransportEvent as V, type WaypointClient as W, type TransportPort as X, asProblem as Y, canTransition as Z, confirmationOf as _, type FormSession as a, createPlanRunner as a0, createWaypointClient as a1, flowTabId as a2, loadFormSession as a3, readProblem as a4, replyRow as a5, versionWalk as a6, SUPPORTED_PROTOCOLS as a7, blockFallback as a8, negotiate as a9, withPrerequisites as aa, type ClientSnapshot as b, type WaypointEvent as c, type ConversationReadResult as d, type ReplyDelivery as e, type ReadPorts as f, type ReplyState as g, CAPABILITIES as h, type Capability as i, type ComposerContribution as j, ConversationReadError as k, type ConversationSource as l, type ConversationSummary as m, FORM_SESSION_UNAVAILABLE as n, type FeedbackInput as o, type FeedbackPort as p, type FlowSource as q, type FlowSummary as r, type FlowTab as s, type FormDraft as t, type FormField as u, type FormMaterial as v, type FormSnapshot as w, type KeepChangesReviewResult as x, type KeepDisabledReason as y, type MessageVersionInput as z };

package/dist/form-session.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkLLPGVQUTcjs = require('./chunk-LLPGVQUT.cjs');require('./chunk-II26UWZM.cjs');exports.createFormSession = _chunkLLPGVQUTcjs.a;

package/dist/form-session.d.cts

@@ -0,0 +1,7 @@
+import { F as FormSessionConfig, a as FormSession } from './form-fill-C32AHxSr.cjs';
+import './generated-C9tbjwK0.cjs';
+import './intent-BQPPows1.cjs';
+
+declare function createFormSession(config: FormSessionConfig): FormSession;
+
+export { createFormSession };

package/dist/form-session.d.ts

@@ -0,0 +1,7 @@
+import { F as FormSessionConfig, a as FormSession } from './form-fill-Dp3ut1_Y.js';
+import './generated-C9tbjwK0.js';
+import './intent-BuvqEU3Q.js';
+
+declare function createFormSession(config: FormSessionConfig): FormSession;
+
+export { createFormSession };

package/dist/form-session.js

@@ -0,0 +1 @@
+import{a}from"./chunk-TCFCSGQ3.js";import"./chunk-5TBO732O.js";export{a as createFormSession};

package/dist/frame-decoder.cjs

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-II26UWZM.cjs');async function*f(l,o){let r="",a=[],i=n=>{if(!n.trim())return null;let e=JSON.parse(n);if(typeof e!="object"||e===null||typeof e.protocol!="string"||!Number.isInteger(e.sequence)||typeof e.type!="string")throw new Error("Invalid frame");return e};for await(let n of l){r+=n;let e;for(;(e=r.indexOf(`
+`))>=0;){let s=r.slice(0,e).replace(/\r$/,"");if(r=r.slice(e+1),o==="ndjson"){let t=i(s);t&&(yield t)}else if(s===""){let t=i(a.join(`
+`));a=[],t&&(yield t)}else s.startsWith("data:")&&a.push(s.slice(5).replace(/^ /,""))}}if(o==="ndjson"){let n=i(r);n&&(yield n)}}exports.decodeFrames = f;

package/dist/frame-decoder.d.cts

@@ -0,0 +1,5 @@
+import { F as Frame } from './generated-C9tbjwK0.cjs';
+
+declare function decodeFrames(chunks: AsyncIterable<string>, format: "sse" | "ndjson"): AsyncGenerator<Frame>;
+
+export { decodeFrames };