@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/openui/index.d.ts

@@ -1,208 +1,26 @@
-import { O as OpenUIFormValues, b as OpenUINode, a as OpenUIFieldIssue, d as OpenUIFormSpec, e as OpenUIFieldKind } from '../values-C7RidJuI.js';
-export { f as OpenUIArtifact, g as OpenUIArtifactError, h as OpenUIArtifactResult, i as OpenUIFieldIssueCode, j as OpenUIFieldSpec, k as OpenUIFormValidation, l as OpenUISegment, c as OpenUIValue, m as hasOpenUISegment, n as isOpenUIFieldKind, o as isSafeOpenUIFieldId, p as parseOpenUIArtifact, q as parseOpenUISegments, v as validateOpenUIFormValues } from '../values-C7RidJuI.js';
-
 /**
- * What travels when a user presses a button on a page the agent authored.
- *
- * The submission is a plain REST body, not a chat turn. That is the entire
- * point of this module: pressing "Recalculate" on an agent-authored form must
- * cost the same as pressing a button on a hand-built screen — one product route
- * call, no model tokens, no sandbox wake-up. The wire shape here is therefore
- * deliberately small and self-contained: an action id, the form it belongs to,
- * that form's current values, and enough addressing for the product to find the
- * page. Nothing in it references a session, a turn, or a run.
- */
-
-/** What the browser POSTs when an action fires. */
-interface OpenUIActionSubmission {
-    /** The action's stable id, as authored on the page. */
-    actionId: string;
-    /** The form whose values are attached, when the action sits in one. */
-    formId?: string;
-    /** Current values of that form, keyed by field id. Empty for a bare action. */
-    values: OpenUIFormValues;
-    /** The node the action was rendered on, when the page carries several. */
-    nodeId?: string;
-    /** Vault path of the persisted `render_ui` artifact this page came from. */
-    artifactPath?: string;
-}
-/** Parsed submission, or the reason the body was refused. */
-type OpenUIActionBodyValidation = {
-    ok: true;
-    submission: OpenUIActionSubmission;
-} | {
-    ok: false;
-    code: OpenUIActionBodyErrorCode;
-    error: string;
-};
-/** Why a submission body was refused before any handler ran. */
-type OpenUIActionBodyErrorCode = 'OPENUI_ACTION_ID_MISSING' | 'OPENUI_ACTION_ID_INVALID' | 'OPENUI_FORM_ID_INVALID' | 'OPENUI_NODE_ID_INVALID' | 'OPENUI_ARTIFACT_PATH_INVALID' | 'OPENUI_VALUES_INVALID' | 'OPENUI_FIELD_ID_INVALID' | 'OPENUI_FIELD_VALUE_INVALID';
-/** Ids the host accepts on the wire: identifier-safe, same rule as field ids. */
-declare function isSafeOpenUIActionId(id: string): boolean;
-/**
- * Validate a raw JSON body into a submission. Every rejection names a code so
- * the browser can tell "the page sent something malformed" from "the product
- * refused the action".
- */
-declare function validateOpenUIActionBody(body: Record<string, unknown>): OpenUIActionBodyValidation;
-/**
- * One plain line recording what the user did, for the product to carry into the
- * NEXT turn's context.
- *
- * The action itself spends no model tokens; without a record of it the agent
- * would later reason about a page the user has already changed. Appending this
- * to the thread (as a note, a system line, or a stored part) is how the agent
- * catches up on the next turn the user actually pays for.
- */
-declare function describeOpenUIAction(submission: OpenUIActionSubmission): string;
-
-/**
- * The host half of an interactive OpenUI page: one POST endpoint that turns a
- * button press into a product function call.
- *
- * THE SEAM THAT KEEPS IT FREE. This factory has no agent connection, no session
- * id, no sandbox, and no turn — look at {@link OpenUIActionRouteOptions}: the
- * only things a product supplies are an authorizer and a map of plain handlers.
- * There is no seam here through which a model call could be made, which is what
- * makes "manipulating agent-authored UI costs nothing" a structural property
- * rather than a promise. Compare `./interactions`, whose answer route exists
- * precisely to unblock a running turn: that one resolves a sidecar connection,
- * and this one cannot.
- *
- * A handler returns data, a replacement page, or a typed failure. If it wants
- * the agent to know what happened, the product records
- * {@link describeOpenUIAction} into the thread — read on the NEXT turn the user
- * chooses to spend, never as a side effect of the click.
- *
- * Handlers return web-standard `Response`s (Workers, Node 18+, Deno).
- */
-
-/** Logging surface the route uses; `console` by default. */
-type OpenUIActionLogger = Pick<Console, 'warn' | 'error'>;
-/** The product's verdict on who is calling. `response` short-circuits with a
- *  product-authored Response (401/403/404/429…). */
-type OpenUIActionResolution<TContext> = {
-    ok: true;
-    context: TContext;
-} | {
-    ok: false;
-    response: Response;
-};
-/** What a handler is given: the caller's request, the parsed submission, and
- *  whatever the product's authorizer resolved. */
-interface OpenUIActionHandlerArgs<TContext> {
-    request: Request;
-    submission: OpenUIActionSubmission;
-    context: TContext;
-}
-/** What a handler returns. A replacement `schema` re-renders the page in place;
- *  `values` writes corrected/derived values back into the form. */
-type OpenUIActionResult<TNode extends OpenUINode = OpenUINode> = {
-    ok: true;
-    /** Short confirmation for the card, in the user's language. */
-    message?: string;
-    /** Values to write back into the form (server-corrected or derived). */
-    values?: OpenUIFormValues;
-    /** A page to render in place of the current one. */
-    schema?: TNode | TNode[];
-    /** Anything else the client should read (totals, ids, links). */
-    data?: Record<string, unknown>;
-} | {
-    ok: false;
-    /** Machine-readable reason, surfaced to the client verbatim. */
-    code: string;
-    /** One sentence the user can act on. */
-    message: string;
-    /** HTTP status; defaults to 400. */
-    status?: number;
-    /** Field-level rejections, so the card can mark the offending inputs. */
-    issues?: OpenUIFieldIssue[];
-};
-/** One product action, keyed in {@link OpenUIActionRouteOptions.actions} by the
- *  `action.id` the agent authored on the page. */
-type OpenUIActionHandler<TContext, TNode extends OpenUINode = OpenUINode> = (args: OpenUIActionHandlerArgs<TContext>) => OpenUIActionResult<TNode> | Promise<OpenUIActionResult<TNode>>;
-/** How the route is wired. Note what is absent: nothing here can reach a model. */
-interface OpenUIActionRouteOptions<TContext, TNode extends OpenUINode = OpenUINode> {
-    /**
-     * Authenticate and authorize the caller, and resolve whatever the handlers
-     * need (db handle, workspace, user). The only product-supplied gate.
-     */
-    resolve: (args: {
-        request: Request;
-        submission: OpenUIActionSubmission;
-    }) => OpenUIActionResolution<TContext> | Promise<OpenUIActionResolution<TContext>>;
-    /** Handlers by action id. An id with no handler is a 404, never a no-op. */
-    actions: Record<string, OpenUIActionHandler<TContext, TNode>>;
-    /**
-     * Form specs by form id. When the submission names a form listed here, its
-     * values are checked against the spec before the handler runs, and rejections
-     * come back as field issues. Omit a form to leave checking to its handler.
-     */
-    forms?: Record<string, OpenUIFormSpec>;
-    /**
-     * Called after a successful handler with the line the agent should read on
-     * its next turn. Persist it against the thread; do NOT start a turn from it.
-     */
-    recordForAgent?: (args: {
-        request: Request;
-        submission: OpenUIActionSubmission;
-        context: TContext;
-        note: string;
-    }) => void | Promise<void>;
-    logger?: OpenUIActionLogger;
-}
-/** The endpoint a product mounts. */
-interface OpenUIActionRoute {
-    /** POST `{ actionId, formId?, values?, nodeId?, artifactPath? }`. */
-    handle: (request: Request) => Promise<Response>;
-}
-/**
- * Build the action endpoint for agent-authored pages.
- *
- * ```ts
- * const route = createOpenUIActionRoute({
- *   resolve: async ({ request }) => {
- *     const session = await auth(request)
- *     if (!session) return { ok: false, response: new Response('Unauthorized', { status: 401 }) }
- *     return { ok: true, context: { db, workspaceId: session.workspaceId } }
- *   },
- *   forms: { deduction_form: DEDUCTION_FORM },
- *   actions: {
- *     recalculate: async ({ submission, context }) => {
- *       const totals = recompute(context.db, submission.values)
- *       return { ok: true, data: totals, schema: totalsPage(totals) }
- *     },
- *   },
- * })
- * export const action = ({ request }: ActionFunctionArgs) => route.handle(request)
- * ```
- */
-declare function createOpenUIActionRoute<TContext, TNode extends OpenUINode = OpenUINode>(options: OpenUIActionRouteOptions<TContext, TNode>): OpenUIActionRoute;
-
-/**
- * What the model is told about writing an interactive page.
- *
- * An agent will not emit a node vocabulary nobody described to it, so the
- * vocabulary and the prompt text that teaches it have to ship together. This
- * module is that text plus the machine-readable field/action shape it
- * describes, so five products do not each write their own (subtly different)
- * version into a system prompt.
- *
- * OPT-IN, DELIBERATELY. The input nodes render only where the host's renderer
- * knows them and the host passes an action handler. Advertise this guide only
- * once both are true for your product — otherwise the agent writes forms the
- * page will drop.
- */
-
-/** The input kinds this guide teaches, in the order it lists them. */
-declare const OPENUI_INPUT_KINDS: readonly OpenUIFieldKind[];
-/**
- * The interactive vocabulary, written for a model.
- *
- * Appended to `render_ui`'s description by
- * `buildAppToolOpenAITools(taxonomy, { interactiveUi: true })`, and usable
- * directly in a system prompt for the inline ```` ```openui ```` path.
+ * `@tangle-network/agent-app/openui` — the host contract for agent-authored UI.
+ *
+ * The agent emits a page (inline ```` ```openui ```` fence, or the `render_ui`
+ * tool). This module is everything the HOST needs around that page and nothing
+ * the renderer owns:
+ *
+ *   - `segments.ts` — split an assistant message into prose and pages, once,
+ *     instead of once per product.
+ *   - `values.ts`   — what a field holds, and whether a submission matches the
+ *     form the agent authored.
+ *   - `action.ts`   — the REST body a button press sends, and the one line the
+ *     agent should read about it on its next turn.
+ *   - `route.ts`    — the endpoint that turns that press into a product function
+ *     call, with no path to a model turn.
+ *   - `authoring.ts` — the vocabulary text that makes the agent emit forms.
+ *
+ * Framework-free and browser-safe: no React, no Node builtins, no runtime. The
+ * client-side half is `@tangle-network/agent-app/openui-react`; the node union
+ * and renderer live in `@tangle-network/ui`'s `./openui` entry.
  */
-declare const OPENUI_INTERACTIVE_AUTHORING_GUIDE: string;
-
-export { OPENUI_INPUT_KINDS, OPENUI_INTERACTIVE_AUTHORING_GUIDE, type OpenUIActionBodyErrorCode, type OpenUIActionBodyValidation, type OpenUIActionHandler, type OpenUIActionHandlerArgs, type OpenUIActionLogger, type OpenUIActionResolution, type OpenUIActionResult, type OpenUIActionRoute, type OpenUIActionRouteOptions, type OpenUIActionSubmission, OpenUIFieldIssue, OpenUIFieldKind, OpenUIFormSpec, OpenUIFormValues, OpenUINode, createOpenUIActionRoute, describeOpenUIAction, isSafeOpenUIActionId, validateOpenUIActionBody };
+export { parseOpenUISegments, hasOpenUISegment, parseOpenUIArtifact, type OpenUINode, type OpenUISegment, type OpenUIArtifact, type OpenUIArtifactError, type OpenUIArtifactResult, } from './segments';
+export { isSafeOpenUIFieldId, isOpenUIFieldKind, validateOpenUIFormValues, type OpenUIValue, type OpenUIFormValues, type OpenUIFieldKind, type OpenUIFieldSpec, type OpenUIFormSpec, type OpenUIFieldIssue, type OpenUIFieldIssueCode, type OpenUIFormValidation, } from './values';
+export { isSafeOpenUIActionId, validateOpenUIActionBody, describeOpenUIAction, type OpenUIActionSubmission, type OpenUIActionBodyValidation, type OpenUIActionBodyErrorCode, } from './action';
+export { createOpenUIActionRoute, type OpenUIActionRoute, type OpenUIActionRouteOptions, type OpenUIActionHandler, type OpenUIActionHandlerArgs, type OpenUIActionResult, type OpenUIActionResolution, type OpenUIActionLogger, } from './route';
+export { OPENUI_INTERACTIVE_AUTHORING_GUIDE, OPENUI_INPUT_KINDS } from './authoring';

package/dist/openui/route.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The host half of an interactive OpenUI page: one POST endpoint that turns a
+ * button press into a product function call.
+ *
+ * THE SEAM THAT KEEPS IT FREE. This factory has no agent connection, no session
+ * id, no sandbox, and no turn — look at {@link OpenUIActionRouteOptions}: the
+ * only things a product supplies are an authorizer and a map of plain handlers.
+ * There is no seam here through which a model call could be made, which is what
+ * makes "manipulating agent-authored UI costs nothing" a structural property
+ * rather than a promise. Compare `./interactions`, whose answer route exists
+ * precisely to unblock a running turn: that one resolves a sidecar connection,
+ * and this one cannot.
+ *
+ * A handler returns data, a replacement page, or a typed failure. If it wants
+ * the agent to know what happened, the product records
+ * {@link describeOpenUIAction} into the thread — read on the NEXT turn the user
+ * chooses to spend, never as a side effect of the click.
+ *
+ * Handlers return web-standard `Response`s (Workers, Node 18+, Deno).
+ */
+import { type OpenUIActionSubmission } from './action';
+import type { OpenUINode } from './segments';
+import { type OpenUIFieldIssue, type OpenUIFormSpec, type OpenUIFormValues } from './values';
+/** Logging surface the route uses; `console` by default. */
+export type OpenUIActionLogger = Pick<Console, 'warn' | 'error'>;
+/** The product's verdict on who is calling. `response` short-circuits with a
+ *  product-authored Response (401/403/404/429…). */
+export type OpenUIActionResolution<TContext> = {
+    ok: true;
+    context: TContext;
+} | {
+    ok: false;
+    response: Response;
+};
+/** What a handler is given: the caller's request, the parsed submission, and
+ *  whatever the product's authorizer resolved. */
+export interface OpenUIActionHandlerArgs<TContext> {
+    request: Request;
+    submission: OpenUIActionSubmission;
+    context: TContext;
+}
+/** What a handler returns. A replacement `schema` re-renders the page in place;
+ *  `values` writes corrected/derived values back into the form. */
+export type OpenUIActionResult<TNode extends OpenUINode = OpenUINode> = {
+    ok: true;
+    /** Short confirmation for the card, in the user's language. */
+    message?: string;
+    /** Values to write back into the form (server-corrected or derived). */
+    values?: OpenUIFormValues;
+    /** A page to render in place of the current one. */
+    schema?: TNode | TNode[];
+    /** Anything else the client should read (totals, ids, links). */
+    data?: Record<string, unknown>;
+} | {
+    ok: false;
+    /** Machine-readable reason, surfaced to the client verbatim. */
+    code: string;
+    /** One sentence the user can act on. */
+    message: string;
+    /** HTTP status; defaults to 400. */
+    status?: number;
+    /** Field-level rejections, so the card can mark the offending inputs. */
+    issues?: OpenUIFieldIssue[];
+};
+/** One product action, keyed in {@link OpenUIActionRouteOptions.actions} by the
+ *  `action.id` the agent authored on the page. */
+export type OpenUIActionHandler<TContext, TNode extends OpenUINode = OpenUINode> = (args: OpenUIActionHandlerArgs<TContext>) => OpenUIActionResult<TNode> | Promise<OpenUIActionResult<TNode>>;
+/** How the route is wired. Note what is absent: nothing here can reach a model. */
+export interface OpenUIActionRouteOptions<TContext, TNode extends OpenUINode = OpenUINode> {
+    /**
+     * Authenticate and authorize the caller, and resolve whatever the handlers
+     * need (db handle, workspace, user). The only product-supplied gate.
+     */
+    resolve: (args: {
+        request: Request;
+        submission: OpenUIActionSubmission;
+    }) => OpenUIActionResolution<TContext> | Promise<OpenUIActionResolution<TContext>>;
+    /** Handlers by action id. An id with no handler is a 404, never a no-op. */
+    actions: Record<string, OpenUIActionHandler<TContext, TNode>>;
+    /**
+     * Form specs by form id. When the submission names a form listed here, its
+     * values are checked against the spec before the handler runs, and rejections
+     * come back as field issues. Omit a form to leave checking to its handler.
+     */
+    forms?: Record<string, OpenUIFormSpec>;
+    /**
+     * Called after a successful handler with the line the agent should read on
+     * its next turn. Persist it against the thread; do NOT start a turn from it.
+     */
+    recordForAgent?: (args: {
+        request: Request;
+        submission: OpenUIActionSubmission;
+        context: TContext;
+        note: string;
+    }) => void | Promise<void>;
+    logger?: OpenUIActionLogger;
+}
+/** The endpoint a product mounts. */
+export interface OpenUIActionRoute {
+    /** POST `{ actionId, formId?, values?, nodeId?, artifactPath? }`. */
+    handle: (request: Request) => Promise<Response>;
+}
+/**
+ * Build the action endpoint for agent-authored pages.
+ *
+ * ```ts
+ * const route = createOpenUIActionRoute({
+ *   resolve: async ({ request }) => {
+ *     const session = await auth(request)
+ *     if (!session) return { ok: false, response: new Response('Unauthorized', { status: 401 }) }
+ *     return { ok: true, context: { db, workspaceId: session.workspaceId } }
+ *   },
+ *   forms: { deduction_form: DEDUCTION_FORM },
+ *   actions: {
+ *     recalculate: async ({ submission, context }) => {
+ *       const totals = recompute(context.db, submission.values)
+ *       return { ok: true, data: totals, schema: totalsPage(totals) }
+ *     },
+ *   },
+ * })
+ * export const action = ({ request }: ActionFunctionArgs) => route.handle(request)
+ * ```
+ */
+export declare function createOpenUIActionRoute<TContext, TNode extends OpenUINode = OpenUINode>(options: OpenUIActionRouteOptions<TContext, TNode>): OpenUIActionRoute;

package/dist/openui/segments.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Splitting an assistant message into prose and agent-authored UI.
+ *
+ * An agent emits a page by fencing it as ```` ```openui ```` in its reply (the
+ * inline path) or by calling `render_ui` (the persisted-artifact path). Every
+ * product that renders the inline path had forked the same scanner into its own
+ * chat-message body; this is that scanner, once, with no React and no renderer
+ * import — the node union stays owned by `@tangle-network/ui`'s `./openui`.
+ */
+/**
+ * The narrowest thing a host can assert about a parsed node: it names a type.
+ * A renderer's node union satisfies this, so
+ * `parseOpenUISegments<OpenUIComponentNode>(text)` hands typed nodes straight
+ * to the renderer with no cast at the call site.
+ */
+export interface OpenUINode {
+    type: string;
+    id?: string;
+}
+/** One piece of an assistant message: prose, or a page to render. */
+export type OpenUISegment<TNode extends OpenUINode = OpenUINode> = {
+    type: 'markdown';
+    text: string;
+} | {
+    type: 'openui';
+    nodes: TNode[];
+};
+/**
+ * Split message content into markdown and OpenUI segments, in source order.
+ *
+ * A fence whose body is not JSON, or whose JSON carries no node at all, is
+ * returned as a fenced `json` markdown segment rather than an empty page: the
+ * content is still streaming, or the agent wrote something malformed, and both
+ * cases are better shown than swallowed into a blank card.
+ *
+ * The type argument is the caller's assertion about the node union it will
+ * render; this function checks only that each node names a `type`, and the
+ * renderer rejects types it does not know.
+ */
+export declare function parseOpenUISegments<TNode extends OpenUINode = OpenUINode>(content: string): Array<OpenUISegment<TNode>>;
+/** Whether a message carries any agent-authored page at all. */
+export declare function hasOpenUISegment(content: string): boolean;
+/** A page read back out of the vault, and its title when one was stored. */
+export interface OpenUIArtifact<TNode extends OpenUINode = OpenUINode> {
+    title?: string;
+    nodes: TNode[];
+}
+/** Why a stored page could not be read. */
+export interface OpenUIArtifactError {
+    code: 'artifact_not_json' | 'artifact_no_nodes';
+    message: string;
+}
+/** Reading a stored page either produces nodes or says why it did not. */
+export type OpenUIArtifactResult<TNode extends OpenUINode = OpenUINode> = {
+    succeeded: true;
+    value: OpenUIArtifact<TNode>;
+} | {
+    succeeded: false;
+    error: OpenUIArtifactError;
+};
+/**
+ * Read a `render_ui` artifact back out of the vault.
+ *
+ * Two shapes are in the wild and a product cannot tell them apart from the
+ * path: the bare node tree that `preset-cloudflare`'s handler writes
+ * (`JSON.stringify(args.schema)`), and the `{ title, schema }` envelope some
+ * products write themselves. Reading only one of them renders an empty panel
+ * for the other, with nothing on screen to say why — so this reads both and
+ * fails loud when it is neither.
+ */
+export declare function parseOpenUIArtifact<TNode extends OpenUINode = OpenUINode>(content: string): OpenUIArtifactResult<TNode>;

package/dist/openui/values.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The value half of an interactive OpenUI page: what a field holds, and whether
+ * a submitted set of field values matches the form the agent authored.
+ *
+ * The NODE vocabulary (which fields exist, how they render) has one owner —
+ * `@tangle-network/ui`'s `./openui` entry. This module does not restate it. It
+ * declares the narrowest STRUCTURAL port a host needs to check a submission:
+ * the field's id, its kind, and the constraints that make a value legal. A
+ * renderer's richer node type satisfies this port by assignment, so the two
+ * packages stay in step without either importing the other.
+ */
+/** A value one OpenUI field can hold. `string[]` is a multi-select. */
+export type OpenUIValue = string | number | boolean | string[];
+/** Submitted field values, keyed by field id. */
+export type OpenUIFormValues = Record<string, OpenUIValue>;
+/**
+ * Field ids the host will accept: identifier-safe, and never a key that would
+ * reach `Object.prototype`. A submission arrives from a browser and is used to
+ * index an object, so this is a boundary check, not a style rule.
+ */
+export declare function isSafeOpenUIFieldId(id: string): boolean;
+/** The input kinds a form field can be. */
+export type OpenUIFieldKind = 'text' | 'number' | 'currency' | 'select' | 'checkbox' | 'slider';
+/** Whether a string names an input kind this contract knows. */
+export declare function isOpenUIFieldKind(kind: string): kind is OpenUIFieldKind;
+/**
+ * One field, reduced to what a value check needs. A renderer node carrying
+ * labels, placeholders, and layout is assignable to this — the extra
+ * presentation properties are simply not read here.
+ */
+export interface OpenUIFieldSpec {
+    id: string;
+    kind: OpenUIFieldKind;
+    required?: boolean;
+    /** `number` / `currency` / `slider` bounds, inclusive. */
+    min?: number;
+    max?: number;
+    /** Increment `number` / `currency` / `slider` values must land on, measured from `min ?? 0`. */
+    step?: number;
+    /** Longest accepted `text` value. */
+    maxLength?: number;
+    /** Accepted `select` values. */
+    options?: ReadonlyArray<{
+        value: string;
+    }>;
+    /** A `select` that accepts more than one option; its value is a `string[]`. */
+    multiple?: boolean;
+}
+/** A form the host can check a submission against. */
+export interface OpenUIFormSpec {
+    id: string;
+    fields: readonly OpenUIFieldSpec[];
+}
+/** Why one field's value was rejected. */
+export type OpenUIFieldIssueCode = 'required' | 'type' | 'range' | 'step' | 'option' | 'length' | 'unknown_field' | 'duplicate_field' | 'unsafe_field_id';
+/** One rejected field, named so a card can mark exactly that input. */
+export interface OpenUIFieldIssue {
+    fieldId: string;
+    code: OpenUIFieldIssueCode;
+    message: string;
+}
+/** The outcome of checking a submission against a form. */
+export type OpenUIFormValidation = {
+    ok: true;
+    values: OpenUIFormValues;
+} | {
+    ok: false;
+    issues: OpenUIFieldIssue[];
+};
+/**
+ * Check submitted values against the form the agent authored.
+ *
+ * Fails loud on both sides of the shape: a value the form never declared is an
+ * error (`unknown_field`), not a silently ignored extra, because a host that
+ * drops it would act on a form different from the one the user filled in. A
+ * `required` field with no value is an error even when the caller simply never
+ * sent the key.
+ *
+ * On success the returned `values` contain only declared fields, in the form's
+ * own field order — the object a handler should act on.
+ */
+export declare function validateOpenUIFormValues(spec: OpenUIFormSpec, values: OpenUIFormValues): OpenUIFormValidation;

package/dist/openui-react/index.d.ts

@@ -1,5 +1,3 @@
-import { O as OpenUIFormValues, a as OpenUIFieldIssue, b as OpenUINode, c as OpenUIValue } from '../values-C7RidJuI.js';
-
 /**
  * `@tangle-network/agent-app/openui-react` — the missing `onAction`.
  *
@@ -14,9 +12,9 @@ import { O as OpenUIFormValues, a as OpenUIFieldIssue, b as OpenUINode, c as Ope
  * costs exactly one product request, the same as a hand-built screen. Tests
  * enforce that by walking this module's imports.
  */
-
+import type { OpenUIFieldIssue, OpenUIFormValues, OpenUINode, OpenUIValue } from '../openui/index';
 /** A successful action reply, as the route sends it. */
-interface OpenUIActionResponse<TNode extends OpenUINode = OpenUINode> {
+export interface OpenUIActionResponse<TNode extends OpenUINode = OpenUINode> {
     ok: true;
     actionId: string;
     message?: string;
@@ -25,14 +23,14 @@ interface OpenUIActionResponse<TNode extends OpenUINode = OpenUINode> {
     data?: Record<string, unknown>;
 }
 /** A refused action, as the route sends it. */
-interface OpenUIActionFailure {
+export interface OpenUIActionFailure {
     code: string;
     error: string;
     actionId?: string;
     issues?: OpenUIFieldIssue[];
 }
 /** The boundary outcome: the reply, or the reason there is none. */
-type OpenUIActionOutcome<TNode extends OpenUINode = OpenUINode> = {
+export type OpenUIActionOutcome<TNode extends OpenUINode = OpenUINode> = {
     succeeded: true;
     value: OpenUIActionResponse<TNode>;
 } | {
@@ -42,13 +40,13 @@ type OpenUIActionOutcome<TNode extends OpenUINode = OpenUINode> = {
 /** Where on the page an action fired, and what the form held at that moment.
  *  A renderer that owns form state passes `values`; otherwise the hook's own
  *  `values` are sent. */
-interface OpenUIActionContext {
+export interface OpenUIActionContext {
     formId?: string;
     nodeId?: string;
     values?: OpenUIFormValues;
 }
 /** How the hook talks to the product route. */
-interface UseOpenUIActionsOptions<TNode extends OpenUINode = OpenUINode> {
+export interface UseOpenUIActionsOptions<TNode extends OpenUINode = OpenUINode> {
     /** The product's action endpoint — a plain REST route, never a chat route. */
     endpoint: string;
     /** Extra routing fields merged into every POST body (workspaceId, threadId).
@@ -67,7 +65,7 @@ interface UseOpenUIActionsOptions<TNode extends OpenUINode = OpenUINode> {
 }
 /** What the hook returns. `onAction` is the renderer prop; the rest is state a
  *  card renders around it. */
-interface OpenUIActionsController<TNode extends OpenUINode = OpenUINode> {
+export interface OpenUIActionsController<TNode extends OpenUINode = OpenUINode> {
     /** Current field values. */
     values: OpenUIFormValues;
     /** Set one field. */
@@ -111,9 +109,7 @@ interface OpenUIActionsController<TNode extends OpenUINode = OpenUINode> {
  * flight is refused with `OPENUI_ACTION_BUSY` rather than racing two writes
  * against the same form.
  */
-declare function useOpenUIActions<TNode extends OpenUINode = OpenUINode>(options: UseOpenUIActionsOptions<TNode>): OpenUIActionsController<TNode>;
+export declare function useOpenUIActions<TNode extends OpenUINode = OpenUINode>(options: UseOpenUIActionsOptions<TNode>): OpenUIActionsController<TNode>;
 /** The body keys the hook owns; a product's extra `body` fields cannot shadow
  *  them. Exported so a route's own tests can assert the same list. */
-declare const OPENUI_RESERVED_BODY_KEYS: readonly string[];
-
-export { OPENUI_RESERVED_BODY_KEYS, type OpenUIActionContext, type OpenUIActionFailure, type OpenUIActionOutcome, type OpenUIActionResponse, type OpenUIActionsController, type UseOpenUIActionsOptions, useOpenUIActions };
+export declare const OPENUI_RESERVED_BODY_KEYS: readonly string[];