@tangle-network/agent-app 0.45.54 → 0.45.56

package/dist/values-C7RidJuI.d.ts

@@ -1,156 +0,0 @@
-/**
- * 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.
- */
-interface OpenUINode {
-    type: string;
-    id?: string;
-}
-/** One piece of an assistant message: prose, or a page to render. */
-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.
- */
-declare function parseOpenUISegments<TNode extends OpenUINode = OpenUINode>(content: string): Array<OpenUISegment<TNode>>;
-/** Whether a message carries any agent-authored page at all. */
-declare function hasOpenUISegment(content: string): boolean;
-/** A page read back out of the vault, and its title when one was stored. */
-interface OpenUIArtifact<TNode extends OpenUINode = OpenUINode> {
-    title?: string;
-    nodes: TNode[];
-}
-/** Why a stored page could not be read. */
-interface OpenUIArtifactError {
-    code: 'artifact_not_json' | 'artifact_no_nodes';
-    message: string;
-}
-/** Reading a stored page either produces nodes or says why it did not. */
-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.
- */
-declare function parseOpenUIArtifact<TNode extends OpenUINode = OpenUINode>(content: string): OpenUIArtifactResult<TNode>;
-
-/**
- * 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. */
-type OpenUIValue = string | number | boolean | string[];
-/** Submitted field values, keyed by field id. */
-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.
- */
-declare function isSafeOpenUIFieldId(id: string): boolean;
-/** The input kinds a form field can be. */
-type OpenUIFieldKind = 'text' | 'number' | 'currency' | 'select' | 'checkbox' | 'slider';
-/** Whether a string names an input kind this contract knows. */
-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.
- */
-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. */
-interface OpenUIFormSpec {
-    id: string;
-    fields: readonly OpenUIFieldSpec[];
-}
-/** Why one field's value was rejected. */
-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. */
-interface OpenUIFieldIssue {
-    fieldId: string;
-    code: OpenUIFieldIssueCode;
-    message: string;
-}
-/** The outcome of checking a submission against a form. */
-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.
- */
-declare function validateOpenUIFormValues(spec: OpenUIFormSpec, values: OpenUIFormValues): OpenUIFormValidation;
-
-export { type OpenUIFormValues as O, type OpenUIFieldIssue as a, type OpenUINode as b, type OpenUIValue as c, type OpenUIFormSpec as d, type OpenUIFieldKind as e, type OpenUIArtifact as f, type OpenUIArtifactError as g, type OpenUIArtifactResult as h, type OpenUIFieldIssueCode as i, type OpenUIFieldSpec as j, type OpenUIFormValidation as k, type OpenUISegment as l, hasOpenUISegment as m, isOpenUIFieldKind as n, isSafeOpenUIFieldId as o, parseOpenUIArtifact as p, parseOpenUISegments as q, validateOpenUIFormValues as v };