@kitn.ai/ui 0.20.1 → 0.22.0

package/dist/schemas.js

@@ -0,0 +1,717 @@
+var R = Object.defineProperty;
+var P = (e, t, i) => t in e ? R(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var w = (e, t, i) => P(e, typeof t != "symbol" ? t + "" : t, i);
+const N = "https://json-schema.org/draft/2020-12/schema", _ = "https://kitn.ai/schemas/card/artifact.schema.json", D = "ArtifactCardData", z = "Generated-artifact viewer payload: a framed preview plus the source files behind it. A deliberately NARROW subset of the Artifact component's props — it says WHAT to show, never how the viewer behaves. Toolbar composition, view-state and the iframe `sandbox` are host-owned and stay off the wire, so a model cannot widen its own sandbox or hide the chrome the user needs to inspect what it built.", M = "object";
+const U = [{ required: ["src"] }, { required: ["files"] }], F = { src: { type: "string", format: "uri", description: "URL the preview iframe frames, and the target of the Home button. Omit for a source-only artifact (`tab: 'code'` with `files`).", "x-kai-format": "url" }, files: { type: "array", description: "Files behind the artifact: the Code tab's tree, each optionally carrying its own preview url and source.", maxItems: 500, items: { type: "object", required: ["path"], additionalProperties: !1, properties: { path: { type: "string", description: "Tree label/key. Folders are built from `/`-delimited segments.", maxLength: 1024 }, url: { type: "string", format: "uri", description: "Where the preview loads this file. Defaults to `path` resolved against `src`.", "x-kai-format": "url" }, code: { type: "string", description: "Source shown in the Code tab. Omit for binary files (image/pdf), which have no code view." }, language: { type: "string", description: "Language id for syntax highlighting (e.g. 'html', 'css', 'tsx').", maxLength: 40 }, type: { type: "string", enum: ["html", "pdf", "image", "other"], description: "File kind. Drives the tree icon and whether the Code view applies; 'pdf' also routes the preview to the inline PDF viewer.", "x-kai-control": "select" }, additions: { type: "integer", minimum: 0, description: "Lines added vs the base. Rendered as a trailing '+N' stat." }, deletions: { type: "integer", minimum: 0, description: "Lines removed vs the base. Rendered as a trailing '-N' stat." }, status: { type: "string", enum: ["added", "modified", "deleted", "renamed", "untracked"], description: "Change status vs the base. Drives a trailing status letter in the conventional VCS hue.", "x-kai-control": "select" } } } }, tab: { type: "string", enum: ["preview", "code"], default: "preview", description: "Which view the card OPENS on. SEED ONLY: the user can switch freely afterwards and a revision of this card will NOT move them back, because the user's choice wins over the model's. A switch is reported back as a `state` patch.", "x-kai-control": "select" }, activeFile: { type: "string", description: "Path of the file selected in the tree when the card FIRST renders (must match a `files[].path`). Seeds the tree highlight, the Code source and the preview. SEED ONLY, like `tab`: revising this card will not move a user who has since selected a different file.", maxLength: 1024 }, displayUrl: { type: "string", description: "Friendly address shown in the path field INSTEAD of the real url, which also makes the field read-only. Use when `src` is not consumer-facing (e.g. a `data:` blob) so a clean address is shown rather than leaking it.", maxLength: 2048 }, height: { description: "Frame height. A bare number is px; a string is any CSS length. Defaults to 420px. REQUIRED CONCEPT, not decoration: the viewer is built to fill its container, and a message thread supplies no height, so the card sets one explicitly or the artifact collapses to zero and renders invisible.", oneOf: [{ type: "number", minimum: 1 }, { type: "string", maxLength: 32 }] } }, J = {
+  $schema: N,
+  $id: _,
+  title: D,
+  description: z,
+  type: M,
+  additionalProperties: !1,
+  anyOf: U,
+  properties: F
+}, Y = "https://json-schema.org/draft/2020-12/schema", B = "https://kitn.ai/schemas/card/card-envelope.schema.json", H = "CardEnvelope", K = "A card the agent/server asks the chat to render. `data` validates against the per-type schema.", W = "object", V = ["type", "id", "data"], G = { type: { type: "string", minLength: 1 }, id: { type: "string", minLength: 1 }, data: {}, title: { type: "string" } }, Q = {
+  $schema: Y,
+  $id: B,
+  title: H,
+  description: K,
+  type: W,
+  required: V,
+  properties: G
+}, X = "https://json-schema.org/draft/2020-12/schema", Z = "https://kitn.ai/schemas/card/card-event.schema.json", ee = "CardEvent", te = "An event a card emits up to the host. `kind` discriminates the payload.", ie = "object", ne = ["kind"], se = { kind: { enum: ["ready", "submit", "action", "send-prompt", "open", "resize", "state", "dismiss", "error"] }, cardId: { type: "string" } }, oe = {
+  $schema: X,
+  $id: Z,
+  title: ee,
+  description: te,
+  type: ie,
+  required: ne,
+  properties: se
+}, re = "https://json-schema.org/draft/2020-12/schema", ae = "https://kitn.ai/schemas/card/choice.schema.json", pe = "ChoiceCardData", de = "Data payload for a `choice` card (CardEnvelope.data when type='choice'). A single-select 'pick one of N rich options' card; activating an option emits the `action` verb.", ce = "object", ue = ["options"], le = { prompt: { type: "string", description: "Optional question/body text rendered above the options. Distinct from CardEnvelope.title (the card chrome heading)." }, submitLabel: { type: "string", description: "Label for the Submit button; default 'Submit'." }, options: { type: "array", minItems: 1, description: "The selectable options, rendered in order. Exactly one can be chosen.", items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1, description: "Emitted as CardEvent.action. Must be unique within `options`. (The reserved id '__other__' is used by the allowOther escape.)", "x-kai-unique": !0 }, label: { type: "string", minLength: 1, description: "Visible option label." }, description: { type: "string", description: "Optional secondary line under the label." }, media: { type: "object", description: "Optional leading media: an image URL or a named icon.", properties: { image: { type: "string", description: "Image URL rendered as a leading thumbnail in the row." }, imageAlt: { type: "string", description: "Accessible alt text for `image` (decorative if omitted)." }, icon: { type: "string", description: "Named icon rendered as a leading glyph." } } }, meta: { type: "string", description: "Trailing freeform text (e.g. a price or badge), right-aligned in the row." }, recommended: { type: "boolean", default: !1, description: "Renders a small 'Recommended' pill near the label." }, disabled: { type: "boolean", default: !1, description: "Option is shown but not selectable, and skipped in keyboard nav." }, payload: { description: "Optional opaque payload echoed back in CardEvent.payload (any JSON)." } } } }, allowOther: { description: "Optional free-text escape ('none of these / specify'). `true` appends a final 'Other…' option; an object customizes its `label`/`placeholder`. Selecting it reveals a text input; the shared Submit button then emits `{ kind:'action', action:'__other__', payload:{ text } }`.", "x-kai-control": "allow-other" }, dismissible: { type: "boolean", default: !1, description: "Show a close affordance that emits the `dismiss` verb. The card collapses to a re-openable 'dismissed' stub; the host decides via `onReopen` whether it comes back live or `expired`." } }, me = {
+  $schema: re,
+  $id: ae,
+  title: pe,
+  description: de,
+  type: ce,
+  required: ue,
+  properties: le
+}, he = "https://json-schema.org/draft/2020-12/schema", ye = "https://kitn.ai/schemas/card/confirm.schema.json", fe = "ConfirmCardData", ge = "Data payload for a `confirm` card (CardEnvelope.data when type='confirm').", be = "object", $e = ["actions"], ve = { heading: { type: "string", description: "Optional in-body heading. Distinct from CardEnvelope.title (the card chrome title)." }, body: { type: "string", description: "Body text. Plain text in v1 (rendered safely; no HTML injection)." }, tone: { type: "string", enum: ["default", "warning", "danger"], default: "default", description: "Overall card tone; 'danger' adds a warning icon + accent for destructive approvals.", "x-kai-control": "tone" }, actions: { type: "array", minItems: 1, maxItems: 4, description: "The choice set. Rendered as buttons in order; max 4 keeps it a decision, not a menu.", items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1, description: "Emitted as CardEvent.action. Must be unique within `actions`.", "x-kai-unique": !0 }, label: { type: "string", minLength: 1, description: "Visible button label." }, style: { type: "string", enum: ["primary", "default", "destructive"], default: "default", description: "Button emphasis. 'destructive' = red/danger; 'primary' = filled accent.", "x-kai-control": "button-style" }, payload: { description: "Optional opaque payload echoed back in CardEvent.payload (any JSON)." }, default: { type: "boolean", default: !1, description: "If true, this action is the keyboard default (Enter) and gets initial focus. At most one should be true; the card uses the first if several are.", "x-kai-default-action": !0 } } } }, dismissible: { type: "boolean", default: !1, description: "Show a close affordance that emits the `dismiss` verb." } }, we = {
+  $schema: he,
+  $id: ye,
+  title: fe,
+  description: ge,
+  type: be,
+  required: $e,
+  properties: ve
+}, xe = "https://json-schema.org/draft/2020-12/schema", ke = "https://kitn.ai/schemas/card/embed.schema.json", Oe = "EmbedCardData", je = "Lazy media-embed payload (YouTube / Vimeo / generic player URL).", Se = "object", Ae = ["provider"], Ie = !1, qe = { provider: { type: "string", enum: ["youtube", "vimeo", "generic"], description: "Media provider. 'generic' frames `url` directly (must be an https embeddable player URL whose origin is app-allowlisted).", "x-kai-control": "select" }, id: { type: "string", description: "Provider video id (required for youtube/vimeo when `url` is absent). e.g. 'dQw4w9WgXcQ'.", maxLength: 64, pattern: "^[A-Za-z0-9_-]+$" }, url: { type: "string", format: "uri", description: "Full media/watch URL. For youtube/vimeo it is parsed to an id; for 'generic' it is the embeddable player src (https only).", "x-kai-format": "url" }, title: { type: "string", description: "Accessible title for the player iframe + the poster label. Strongly recommended for a11y.", maxLength: 300 }, poster: { type: "string", format: "uri", description: "Thumbnail shown before play. When omitted, youtube/vimeo derive a default thumbnail; 'generic' shows a neutral play placeholder.", "x-kai-format": "url" }, start: { type: "integer", minimum: 0, description: "Optional start offset in seconds.", "x-kai-unit": "seconds" }, aspectRatio: { type: "string", enum: ["16:9", "4:3", "1:1", "9:16"], default: "16:9", description: "Player box aspect ratio (CSS aspect-ratio).", "x-kai-control": "select" } }, Le = [{ if: { properties: { provider: { const: "generic" } } }, then: { required: ["url"] } }, { if: { properties: { provider: { enum: ["youtube", "vimeo"] } } }, then: { anyOf: [{ required: ["id"] }, { required: ["url"] }] } }], Ce = {
+  $schema: xe,
+  $id: ke,
+  title: Oe,
+  description: je,
+  type: Se,
+  required: Ae,
+  additionalProperties: Ie,
+  properties: qe,
+  allOf: Le
+}, Ee = "https://json-schema.org/draft/2020-12/schema", Te = "https://kitn.ai/schemas/card/form.result.schema.json", Re = "kai-form submit payload", Pe = "The CardEvent {kind:'submit'} `data` for a form card: an object that validates against the form-definition schema that was sent down in CardEnvelope.data. Standard JSON Schema validation (type/enum/required/min-max/length/pattern) holds. Optional empty strings are omitted.", Ne = "object", _e = {
+  $schema: Ee,
+  $id: Te,
+  title: Re,
+  description: Pe,
+  type: Ne
+}, De = "https://json-schema.org/draft/2020-12/schema", ze = "https://kitn.ai/schemas/card/form.schema.json", Me = "kai-form data (a form definition)", Ue = "The CardEnvelope.data for a card of type 'form': a JSON Schema (type:'object') describing the fields kai-form renders, plus optional x-kai-* UI hints. The same schema validates the submission.", Fe = "object", Je = ["type", "properties"], Ye = { type: { const: "object" }, title: { type: "string" }, description: { type: "string" }, required: { type: "array", items: { type: "string" } }, properties: { type: "object" }, "x-kai-order": { type: "array", items: { type: "string" } }, "x-kai-inlineMax": { type: "integer", minimum: 1 }, "x-kai-submitLabel": { type: "string" }, "x-kai-dismissible": { type: "boolean" }, "x-kai-actions": { type: "array", items: { type: "object", required: ["id", "label"], properties: { id: { type: "string" }, label: { type: "string" }, variant: { enum: ["default", "ghost", "outline"] } } } } }, Be = {
+  $schema: De,
+  $id: ze,
+  title: Me,
+  description: Ue,
+  type: Fe,
+  required: Je,
+  properties: Ye
+}, He = "https://json-schema.org/draft/2020-12/schema", Ke = "https://kitn.ai/schemas/card/link.schema.json", We = "LinkPreviewData", Ve = "Rich link / Open-Graph preview payload. The card renders from this; it never fetches.", Ge = "object", Qe = ["url"], Xe = !1, Ze = { url: { type: "string", format: "uri", description: "Canonical destination. Opened via the contract `open` verb (target 'tab').", "x-kai-format": "url" }, title: { type: "string", description: "OG title (og:title). Falls back to the domain when absent.", maxLength: 300 }, description: { type: "string", description: "OG description (og:description). Clamped to 3 lines in the UI.", maxLength: 1e3 }, image: { type: "string", format: "uri", description: "Preview image (og:image). Optional; the card degrades gracefully when missing or it fails to load.", "x-kai-format": "url" }, imageAlt: { type: "string", description: "Alt text for the preview image. Defaults to the title (or empty = decorative) when omitted.", maxLength: 300 }, favicon: { type: "string", format: "uri", description: "Site favicon shown next to the domain.", "x-kai-format": "url" }, domain: { type: "string", description: "Display domain (e.g. 'example.com'). Derived from `url` when omitted.", maxLength: 253 }, siteName: { type: "string", description: "OG site name (og:site_name). Shown in place of the domain when present.", maxLength: 200 } }, et = {
+  $schema: He,
+  $id: Ke,
+  title: We,
+  description: Ve,
+  type: Ge,
+  required: Qe,
+  additionalProperties: Xe,
+  properties: Ze
+}, tt = "https://json-schema.org/draft/2020-12/schema", it = "https://kitn.ai/schemas/card/tasks.result.schema.json", nt = "TasksCardResult", st = "Payload of CardEvent { kind: 'submit' } from a tasks card.", ot = "object", rt = ["selected"], at = { selected: { type: "array", description: "Ids of the checked tasks, in the order they appear in `tasks`. Subset of the input task ids.", items: { type: "string", minLength: 1 }, uniqueItems: !0 } }, pt = {
+  $schema: tt,
+  $id: it,
+  title: nt,
+  description: st,
+  type: ot,
+  required: rt,
+  properties: at
+}, dt = "https://json-schema.org/draft/2020-12/schema", ct = "https://kitn.ai/schemas/card/tasks.schema.json", ut = "TasksCardData", lt = "Data payload for a `tasks` card (CardEnvelope.data when type='tasks').", mt = "object", ht = ["tasks"], yt = { mode: { type: "string", enum: ["select", "progress"], default: "select", description: "'select' (default) = toggle + a confirm button that emits `submit`. 'progress' = an onboarding-checklist look (header `done / total` count, circular indicators, per-item title/description, no confirm button, where checking a row IS the action). Both share the selection model.", "x-kai-mode": !0 }, heading: { type: "string", description: "Optional in-body heading; distinct from CardEnvelope.title." }, tasks: { type: "array", minItems: 1, description: "The selectable rows, rendered in order.", items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1, description: "Stable id; the selected ids are returned in the result. Unique within `tasks`.", "x-kai-unique": !0 }, label: { type: "string", minLength: 1, description: "Row label." }, description: { type: "string", description: "Optional secondary line under the label." }, checked: { type: "boolean", default: !1, description: "Initial checked state of the row." }, disabled: { type: "boolean", default: !1, description: "Row is shown but not toggleable (and excluded from select-all)." } } } }, selectAll: { type: "boolean", default: !1, description: "Render a master select-all checkbox above the list.", "x-kai-control": "select-all" }, confirmLabel: { type: "string", default: "Confirm", description: "Label for the confirm button." }, allowEmpty: { type: "boolean", default: !1, description: "If true, confirm is enabled with zero selected (emits { selected: [] }). If false, confirm is disabled until >=1 selected." }, min: { type: "integer", minimum: 0, description: "Optional minimum number that must be selected to confirm.", "x-kai-select-min": !0 }, max: { type: "integer", minimum: 1, description: "Optional maximum selectable; further toggles are blocked once reached.", "x-kai-select-max": !0 }, dismissible: { type: "boolean", default: !1, description: "Show a close affordance that emits the `dismiss` verb. The card collapses to a re-openable 'dismissed' stub; the host decides via `onReopen` whether it comes back live or `expired`." } }, ft = {
+  $schema: dt,
+  $id: ct,
+  title: ut,
+  description: lt,
+  type: mt,
+  required: ht,
+  properties: yt
+}, S = "kai_";
+function q(e) {
+  if (!e.startsWith(S)) return null;
+  const t = e.slice(S.length);
+  return t.length > 0 ? t : null;
+}
+function gt(e) {
+  return `${S}${e}`;
+}
+function Ht(e) {
+  return q(e) !== null;
+}
+function Kt(e, t, i) {
+  const s = q(e);
+  return s === null ? null : { type: s, id: i.id, data: t === void 0 ? {} : t };
+}
+const L = (e) => Object.freeze(e), C = Object.freeze({
+  id: "openai",
+  label: "OpenAI strict",
+  source: "https://developers.openai.com/api/docs/guides/structured-outputs",
+  checkedOn: "2026-08-11",
+  requireAdditionalPropertiesFalse: !0,
+  requireAllPropertiesRequired: !0,
+  allowRootAnyOf: !1,
+  allowRecursion: !0,
+  keywords: L({
+    // core
+    type: { status: "supported", note: "String, Number, Boolean, Integer, Object, Array are the supported types" },
+    properties: { status: "supported", note: "objects are a supported type" },
+    items: { status: "supported", note: "arrays are a supported type" },
+    required: { status: "supported", note: "required; every property must appear in it" },
+    additionalProperties: {
+      status: "supported",
+      note: "must always be set to false on objects",
+      value: (e) => e === !1 ? null : "must be exactly `false` on every object"
+    },
+    enum: { status: "supported", note: "Enum is a supported type; up to 1000 values across the schema" },
+    const: { status: "supported", note: "const values are counted by the documented 120,000-char name/value budget" },
+    $ref: { status: "supported", note: "internal $ref and $defs are supported, including recursive schemas" },
+    $defs: { status: "supported", note: "definition names are counted by the documented char budget" },
+    definitions: { status: "supported", note: "draft-07 spelling of $defs" },
+    $anchor: { status: "unsupported", note: "not documented in the supported subset" },
+    $schema: { status: "unsupported", note: "meta keyword, not part of the documented subset (the projection strips it)" },
+    $id: { status: "unsupported", note: "meta keyword, not part of the documented subset (the projection strips it)" },
+    // annotations: cannot constrain an instance, so cannot change the grammar
+    title: { status: "annotation", note: "annotation only; cannot constrain an instance" },
+    description: { status: "annotation", note: "annotation only; this is how the model learns the field, keep it" },
+    default: {
+      status: "annotation",
+      note: "not in the supported list, but an annotation under the JSON Schema spec, so it cannot change the compiled grammar"
+    },
+    examples: { status: "annotation", note: "annotation only" },
+    deprecated: { status: "annotation", note: "annotation only" },
+    readOnly: { status: "annotation", note: "annotation only" },
+    writeOnly: { status: "annotation", note: "annotation only" },
+    $comment: { status: "annotation", note: "annotation only" },
+    // strings
+    pattern: { status: "supported", note: "listed under supported String properties" },
+    format: {
+      status: "supported",
+      note: "listed under supported String properties, for a CLOSED list of format values",
+      // Note the absence of `uri`. Anthropic's list has it; OpenAI's does not, and
+      // the kit's link/embed/artifact schemas all use `format: "uri"`.
+      value: (e) => {
+        const t = ["date-time", "time", "date", "duration", "email", "hostname", "ipv4", "ipv6", "uuid"];
+        return typeof e == "string" && t.includes(e) ? null : `format ${JSON.stringify(e)} is outside the supported list (${t.join(", ")})`;
+      }
+    },
+    minLength: { status: "unsupported", note: 'absent from "Supported properties" for strings; see the coin-flip note above this table' },
+    maxLength: { status: "unsupported", note: 'absent from "Supported properties" for strings; see the coin-flip note above this table' },
+    // numbers
+    minimum: { status: "supported", note: "listed under supported Number properties" },
+    maximum: { status: "supported", note: "listed under supported Number properties" },
+    exclusiveMinimum: { status: "supported", note: "listed under supported Number properties" },
+    exclusiveMaximum: { status: "supported", note: "listed under supported Number properties" },
+    multipleOf: { status: "supported", note: "listed under supported Number properties" },
+    // arrays
+    // THE TELL. Any value is fine here; Anthropic accepts only 0 and 1.
+    minItems: { status: "supported", note: "listed under supported Array properties, at any value" },
+    maxItems: { status: "supported", note: "listed under supported Array properties" },
+    uniqueItems: { status: "unsupported", note: "not listed under supported Array properties" },
+    contains: { status: "unsupported", note: "not listed under supported Array properties" },
+    minContains: { status: "unsupported", note: "not listed under supported Array properties" },
+    maxContains: { status: "unsupported", note: "not listed under supported Array properties" },
+    prefixItems: { status: "unsupported", note: "not listed under supported Array properties" },
+    unevaluatedItems: { status: "unsupported", note: "not listed under supported Array properties" },
+    additionalItems: { status: "unsupported", note: "not listed under supported Array properties" },
+    // objects
+    patternProperties: { status: "unsupported", note: "explicitly listed as not yet supported" },
+    propertyNames: { status: "unsupported", note: "not listed under supported Object properties" },
+    minProperties: { status: "unsupported", note: "not listed under supported Object properties" },
+    maxProperties: { status: "unsupported", note: "not listed under supported Object properties" },
+    unevaluatedProperties: { status: "unsupported", note: "not listed under supported Object properties" },
+    // composition
+    anyOf: { status: "supported", note: "a supported type; every nested schema must itself stay in subset, and it may not be at the root" },
+    allOf: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    oneOf: { status: "unsupported", note: "not among the supported types (only `anyOf` is)" },
+    not: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    if: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    then: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    else: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    dependentRequired: { status: "unsupported", note: "explicitly listed as not supported under Composition" },
+    dependentSchemas: { status: "unsupported", note: "explicitly listed as not supported under Composition" }
+  })
+}), E = Object.freeze({
+  id: "anthropic",
+  label: "Anthropic strict",
+  source: "https://platform.claude.com/docs/en/build-with-claude/structured-outputs#json-schema-limitations",
+  checkedOn: "2026-08-11",
+  requireAdditionalPropertiesFalse: !0,
+  // Anthropic's own example leaves `unit` out of `required`. Optional is legal.
+  requireAllPropertiesRequired: !1,
+  allowRootAnyOf: !0,
+  allowRecursion: !1,
+  keywords: L({
+    // core
+    type: { status: "supported", note: "all basic types: object, array, string, integer, number, boolean, null" },
+    properties: { status: "supported", note: "objects are a supported type" },
+    items: { status: "supported", note: "arrays are a supported type" },
+    required: { status: "supported", note: "explicitly supported; leaving a property out of it is legal" },
+    additionalProperties: {
+      status: "supported",
+      note: "must be set to false for objects; anything else is explicitly unsupported",
+      value: (e) => e === !1 ? null : 'must be exactly `false` ("additionalProperties set to anything other than false" is unsupported)'
+    },
+    enum: { status: "supported", note: "strings, numbers, bools or nulls only; complex types within enums are unsupported" },
+    const: { status: "supported", note: "explicitly supported" },
+    $ref: { status: "supported", note: "internal only; external $ref and recursive schemas are unsupported" },
+    $defs: { status: "supported", note: '"$ref, $def, and definitions" are supported' },
+    definitions: { status: "supported", note: '"$ref, $def, and definitions" are supported' },
+    $anchor: { status: "unsupported", note: "not in the supported list" },
+    $schema: { status: "unsupported", note: "meta keyword, not in the supported list (the projection strips it)" },
+    $id: { status: "unsupported", note: "meta keyword, not in the supported list (the projection strips it)" },
+    // annotations
+    title: { status: "annotation", note: "annotation only; cannot constrain an instance" },
+    description: { status: "annotation", note: "annotation only; this is how the model learns the field, keep it" },
+    default: { status: "supported", note: 'explicitly supported: "default property for all supported types"' },
+    examples: { status: "annotation", note: "annotation only" },
+    deprecated: { status: "annotation", note: "annotation only" },
+    readOnly: { status: "annotation", note: "annotation only" },
+    writeOnly: { status: "annotation", note: "annotation only" },
+    $comment: { status: "annotation", note: "annotation only" },
+    // strings
+    // OpenAI supports `pattern`. This subset does not list it at all.
+    pattern: { status: "unsupported", note: "not in the supported list; `format` is the only supported string constraint" },
+    format: {
+      status: "supported",
+      note: "supported for a CLOSED list of format values",
+      // Note `uri` IS here. It is absent from OpenAI's list.
+      value: (e) => {
+        const t = ["date-time", "time", "date", "duration", "email", "hostname", "uri", "ipv4", "ipv6", "uuid"];
+        return typeof e == "string" && t.includes(e) ? null : `format ${JSON.stringify(e)} is outside the supported list (${t.join(", ")})`;
+      }
+    },
+    minLength: { status: "unsupported", note: 'explicitly unsupported: "String constraints (minLength, maxLength)"' },
+    maxLength: { status: "unsupported", note: 'explicitly unsupported: "String constraints (minLength, maxLength)"' },
+    // numbers: all explicitly unsupported here, all supported on OpenAI
+    minimum: { status: "unsupported", note: 'explicitly unsupported: "Numerical constraints (such as minimum, maximum, multipleOf)"' },
+    maximum: { status: "unsupported", note: 'explicitly unsupported: "Numerical constraints (such as minimum, maximum, multipleOf)"' },
+    exclusiveMinimum: { status: "unsupported", note: "a numerical constraint; explicitly unsupported" },
+    exclusiveMaximum: { status: "unsupported", note: "a numerical constraint; explicitly unsupported" },
+    multipleOf: { status: "unsupported", note: 'explicitly unsupported: "Numerical constraints (such as minimum, maximum, multipleOf)"' },
+    // arrays
+    // THE TELL. OpenAI takes any value; this takes 0 or 1 and 400s on 2.
+    minItems: {
+      status: "supported",
+      note: 'supported for values 0 and 1 ONLY: "Array minItems (only values 0 and 1 supported)"',
+      value: (e) => e === 0 || e === 1 ? null : `minItems ${JSON.stringify(e)} is unsupported; only 0 and 1 are`
+    },
+    maxItems: { status: "unsupported", note: 'explicitly unsupported: "Array constraints beyond minItems of 0 or 1"' },
+    uniqueItems: { status: "unsupported", note: "an array constraint beyond minItems 0 or 1; explicitly unsupported" },
+    contains: { status: "unsupported", note: "an array constraint beyond minItems 0 or 1; explicitly unsupported" },
+    minContains: { status: "unsupported", note: "an array constraint beyond minItems 0 or 1; explicitly unsupported" },
+    maxContains: { status: "unsupported", note: "an array constraint beyond minItems 0 or 1; explicitly unsupported" },
+    prefixItems: { status: "unsupported", note: "not in the supported list" },
+    unevaluatedItems: { status: "unsupported", note: "not in the supported list" },
+    additionalItems: { status: "unsupported", note: "not in the supported list" },
+    // objects
+    patternProperties: { status: "unsupported", note: "not in the supported list" },
+    propertyNames: { status: "unsupported", note: "not in the supported list" },
+    minProperties: { status: "unsupported", note: "not in the supported list" },
+    maxProperties: { status: "unsupported", note: "not in the supported list" },
+    unevaluatedProperties: { status: "unsupported", note: "not in the supported list" },
+    // composition
+    anyOf: { status: "supported", note: "explicitly supported, including at the root" },
+    allOf: { status: "supported", note: "explicitly supported, EXCEPT in combination with $ref" },
+    oneOf: { status: "unsupported", note: "not in the supported list (only anyOf and allOf are)" },
+    not: { status: "unsupported", note: "not in the supported list" },
+    if: { status: "unsupported", note: "not in the supported list; conditional application has no supported spelling" },
+    then: { status: "unsupported", note: "not in the supported list; conditional application has no supported spelling" },
+    else: { status: "unsupported", note: "not in the supported list; conditional application has no supported spelling" },
+    dependentRequired: { status: "unsupported", note: "not in the supported list" },
+    dependentSchemas: { status: "unsupported", note: "not in the supported list" }
+  })
+}), Wt = Object.freeze({
+  openai: C,
+  anthropic: E
+}), bt = ["items", "if", "then", "else", "not", "contains", "propertyNames", "unevaluatedItems", "additionalItems"], $t = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"], vt = ["allOf", "anyOf", "oneOf", "prefixItems"], O = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function wt(e, t) {
+  return e === "(root)" ? t : `${e}.${t}`;
+}
+function xt(e, t) {
+  const i = [];
+  return x(e, t, "(root)", !0, i), i;
+}
+function x(e, t, i, s, a) {
+  if (typeof e == "boolean") return;
+  if (!O(e)) {
+    a.push({ path: i, keyword: "(schema)", reason: `expected a schema object, got ${e === null ? "null" : typeof e}` });
+    return;
+  }
+  for (const [p, c] of Object.entries(e)) {
+    const u = t.keywords[p];
+    if (!u) {
+      a.push({
+        path: i,
+        keyword: p,
+        reason: p.startsWith("x-") ? `vendor extension keyword, not in the ${t.label} subset` : `unknown keyword, not classified by the ${t.label} subset`
+      });
+      continue;
+    }
+    if (u.status === "unsupported") {
+      a.push({ path: i, keyword: p, reason: `not supported (${u.note})` });
+      continue;
+    }
+    if (u.status === "supported" && u.value) {
+      const h = u.value(c);
+      h && a.push({ path: i, keyword: p, reason: h });
+    }
+  }
+  const n = O(e.properties), r = e.type === "object" || n;
+  if (r && t.requireAdditionalPropertiesFalse && e.additionalProperties !== !1 && a.push({
+    path: i,
+    keyword: "additionalProperties",
+    reason: `missing; ${t.label} requires \`additionalProperties: false\` on every object`
+  }), r && !n && a.push({
+    path: i,
+    keyword: "properties",
+    reason: `a free-form object (\`type: "object"\` with no \`properties\`) has no grammar under ${t.label}; with the mandatory \`additionalProperties: false\` it can only ever be \`{}\`, which is not what the schema means`
+  }), r && t.requireAllPropertiesRequired && n) {
+    const p = Array.isArray(e.required) ? e.required.map(String) : [], c = Object.keys(e.properties).filter((u) => !p.includes(u));
+    c.length > 0 && a.push({
+      path: i,
+      keyword: "required",
+      reason: `${t.label} requires every property in \`required\`; missing ${c.map((u) => `\`${u}\``).join(", ")} (emulate optional with a \`null\` union)`
+    });
+  }
+  s && !t.allowRootAnyOf && "anyOf" in e && a.push({
+    path: i,
+    keyword: "anyOf",
+    reason: `${t.label} forbids \`anyOf\` at the ROOT ("Root level object of a schema must be an object, and not use anyOf")`
+  }), Object.keys(e).filter((p) => {
+    var c;
+    return ((c = t.keywords[p]) == null ? void 0 : c.status) !== "annotation";
+  }).length === 0 && a.push({
+    path: i,
+    keyword: "type",
+    reason: `unconstrained subschema (annotations only); ${t.label} compiles the schema to a grammar and has no way to express "any JSON". Give it a \`type\``
+  });
+  const m = (p) => {
+    var c;
+    return ((c = t.keywords[p]) == null ? void 0 : c.status) === "unsupported";
+  };
+  for (const p of $t) {
+    const c = e[p];
+    if (!(!O(c) || m(p)))
+      for (const [u, h] of Object.entries(c))
+        x(h, t, p === "properties" ? wt(i, u) : `${i}/${p}[${u}]`, !1, a);
+  }
+  for (const p of bt) {
+    if (!(p in e) || m(p)) continue;
+    const c = e[p];
+    typeof c != "boolean" && x(c, t, p === "items" ? `${i === "(root)" ? "(root)" : i}[]` : `${i}/${p}`, !1, a);
+  }
+  O(e.additionalProperties) && x(e.additionalProperties, t, `${i}/additionalProperties`, !1, a);
+  for (const p of vt) {
+    const c = e[p];
+    !Array.isArray(c) || m(p) || c.forEach((u, h) => x(u, t, `${i}/${p}[${h}]`, !1, a));
+  }
+}
+const kt = Object.freeze({
+  confirm: "Show the user an approval card and wait for their decision before you act. Use this whenever you are about to do something consequential, destructive or irreversible.",
+  choice: "Ask the user to pick exactly one option from a list of rich choices. Use this instead of asking in prose when the options are known and finite.",
+  tasks: "Show the user a checklist they can tick, either to select several items for you to act on or to track progress through a sequence of steps.",
+  form: "Ask the user for structured input by rendering a form. The data is itself a JSON Schema describing the fields to collect.",
+  link: "Show a rich preview of a web page: title, description, image and domain. The card renders what you supply and never fetches the page itself.",
+  embed: "Embed a video player (YouTube, Vimeo, or a direct player URL) inline in the conversation.",
+  artifact: "Show something you built (a page, an app, a set of files) in a framed preview with its source alongside, so the user can look at both."
+});
+class Ot extends Error {
+  constructor(i, s) {
+    super(jt(i, s));
+    w(this, "name", "UnsupportedCardToolSchemaError");
+    w(this, "provider");
+    w(this, "source");
+    w(this, "cards");
+    this.provider = i.id, this.source = i.source, this.cards = s;
+  }
+  /** Every distinct keyword named across every failing card, deduped, in order. */
+  get keywords() {
+    const i = /* @__PURE__ */ new Set();
+    for (const s of this.cards) for (const a of s.violations) i.add(a.keyword);
+    return [...i];
+  }
+}
+function jt(e, t) {
+  const i = [], s = t.length === 1 ? "card type" : "card types";
+  i.push(`${t.length} ${s} cannot be a STRICT tool definition under ${e.label}:`);
+  for (const a of t) {
+    i.push(""), i.push(`  ${a.toolName} (card type "${a.cardType}") — ${a.violations.length} problem(s):`);
+    for (const n of a.violations)
+      i.push(`    ${n.path}: \`${n.keyword}\` — ${n.reason}`);
+  }
+  return i.push(""), i.push(`  subset source: ${e.source} (read ${e.checkedOn})`), i.push(
+    "  Fix: drop `strict: true`. Non-strict is the default and is the mode the kit's cards are proven in; both providers accept a loose schema there and ignore what they do not compile. Rewriting a built-in card schema to fit a strict subset would change what a valid card IS, which is a card-contract change, not a projection setting."
+  ), i.join(`
+`);
+}
+const g = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function St(e) {
+  return e === "$schema" || e === "$id" || e.startsWith("x-");
+}
+const At = ["items", "if", "then", "else", "not", "contains", "propertyNames", "unevaluatedItems", "additionalItems"], It = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"], qt = ["allOf", "anyOf", "oneOf", "prefixItems"];
+function k(e, t) {
+  if (!g(e)) return e;
+  const i = {};
+  for (const [n, r] of Object.entries(e))
+    St(n) || (i[n] = r);
+  for (const n of It) {
+    const r = i[n];
+    if (!g(r)) continue;
+    const o = {};
+    for (const [m, p] of Object.entries(r)) o[m] = k(p, t);
+    i[n] = o;
+  }
+  for (const n of At)
+    !(n in i) || typeof i[n] == "boolean" || (i[n] = k(i[n], t));
+  g(i.additionalProperties) && (i.additionalProperties = k(i.additionalProperties, t));
+  for (const n of qt) {
+    const r = i[n];
+    Array.isArray(r) && (i[n] = r.map((o) => k(o, t)));
+  }
+  const s = g(i.properties) ? i.properties : void 0, a = i.type === "object" || s !== void 0;
+  if (a && t.closeObjects && !("additionalProperties" in i) && (i.additionalProperties = !1), a && t.requireEveryProperty && s) {
+    const n = Array.isArray(i.required) ? i.required.map(String) : [], r = Object.keys(s);
+    for (const o of r)
+      n.includes(o) || (s[o] = Lt(s[o]));
+    i.required = r;
+  }
+  return i;
+}
+function Lt(e) {
+  if (!g(e)) return e;
+  const t = { ...e };
+  if ("type" in t) {
+    const i = Array.isArray(t.type) ? t.type.map(String) : [String(t.type)];
+    i.includes("null") || (t.type = [...i, "null"]);
+  } else if (Array.isArray(t.anyOf))
+    t.anyOf.some((i) => g(i) && i.type === "null") || (t.anyOf = [...t.anyOf, { type: "null" }]);
+  else
+    return t;
+  return Array.isArray(t.enum) && !t.enum.includes(null) && (t.enum = [...t.enum, null]), t;
+}
+function Ct(e) {
+  const t = e;
+  return g(t.schemas) ? { schemas: t.schemas, descriptions: t.descriptions ?? {} } : { schemas: e, descriptions: {} };
+}
+function Et(e, t, i) {
+  const s = i[e];
+  if (typeof s == "string" && s.length > 0) return s;
+  const a = kt[e];
+  if (typeof a == "string" && a.length > 0) return a;
+  const n = t.description;
+  return typeof n == "string" && n.length > 0 ? n : `Render a \`${e}\` card.`;
+}
+function v(e, t) {
+  const i = t === void 0, s = i ? e : t;
+  if (!g(s) || typeof s.provider != "string")
+    throw new TypeError('cardTools: an options object with a `provider` is required, e.g. cardTools({ provider: "openai" })');
+  const { schemas: a, descriptions: n } = Ct(
+    i ? Tt() : e
+  ), r = s.strict === !0;
+  if (s.provider === "jsonschema" && r)
+    throw new TypeError(
+      'cardTools: `strict: true` is provider-specific and cannot be checked for `provider: "jsonschema"`, because the two documented strict subsets differ (see @kitn.ai/ui/schemas provider-subsets). Pass provider "openai" or "anthropic" to project and check strictly, or drop `strict`.'
+    );
+  const o = r ? s.provider === "openai" ? C : E : null, m = {
+    closeObjects: o !== null,
+    requireEveryProperty: o !== null && o.requireAllPropertiesRequired
+  }, p = [], c = [];
+  for (const [u, h] of Object.entries(a)) {
+    const b = gt(u), f = Et(u, h, n), $ = k(h, m);
+    if (o) {
+      const d = xt($, o);
+      if (d.length > 0) {
+        c.push({ cardType: u, toolName: b, violations: d });
+        continue;
+      }
+    }
+    s.provider === "openai" ? p.push({ type: "function", function: { name: b, description: f, parameters: $, ...r ? { strict: !0 } : {} } }) : s.provider === "anthropic" ? p.push({ name: b, description: f, input_schema: $, ...r ? { strict: !0 } : {} }) : p.push({ name: b, description: f, schema: $ });
+  }
+  if (o && c.length > 0) throw new Ot(o, c);
+  return p;
+}
+function Tt() {
+  return j;
+}
+function Vt(e, t) {
+  return e === void 0 ? v({ provider: "openai", strict: t == null ? void 0 : t.strict }) : v(e, { provider: "openai", strict: t == null ? void 0 : t.strict });
+}
+function Gt(e, t) {
+  return e === void 0 ? v({ provider: "anthropic", strict: t == null ? void 0 : t.strict }) : v(e, { provider: "anthropic", strict: t == null ? void 0 : t.strict });
+}
+function Qt(e) {
+  return e === void 0 ? v({ provider: "jsonschema" }) : v(e, { provider: "jsonschema" });
+}
+function A(e) {
+  return e === null ? "null" : Array.isArray(e) ? "array" : typeof e;
+}
+function Rt(e, t) {
+  switch (t) {
+    case "integer":
+      return typeof e == "number" && Number.isInteger(e);
+    case "number":
+      return typeof e == "number" && Number.isFinite(e);
+    case "array":
+      return Array.isArray(e);
+    case "null":
+      return e === null;
+    case "object":
+      return A(e) === "object";
+    default:
+      return typeof e === t;
+  }
+}
+function I(e, t, i, s) {
+  const a = i || "(root)", n = (r, o, m = a) => {
+    s.push({ path: m, keyword: r, message: `${m}: ${o}` });
+  };
+  if (e.type && !Rt(t, e.type)) {
+    n("type", `expected ${e.type}, got ${A(t)}`);
+    return;
+  }
+  if ("const" in e && JSON.stringify(t) !== JSON.stringify(e.const) && n("const", `must equal const ${JSON.stringify(e.const)}`), e.enum && !e.enum.some((r) => JSON.stringify(r) === JSON.stringify(t)) && n("enum", `must be one of ${JSON.stringify(e.enum)}`), typeof t == "number" && (e.minimum !== void 0 && t < e.minimum && n("minimum", `< minimum ${e.minimum}`), e.maximum !== void 0 && t > e.maximum && n("maximum", `> maximum ${e.maximum}`), e.exclusiveMinimum !== void 0 && t <= e.exclusiveMinimum && n("exclusiveMinimum", "<= exclusiveMinimum"), e.exclusiveMaximum !== void 0 && t >= e.exclusiveMaximum && n("exclusiveMaximum", ">= exclusiveMaximum")), typeof t == "string" && (e.minLength !== void 0 && t.length < e.minLength && n("minLength", `shorter than minLength ${e.minLength}`), e.maxLength !== void 0 && t.length > e.maxLength && n("maxLength", `longer than maxLength ${e.maxLength}`), e.pattern !== void 0 && !new RegExp(e.pattern).test(t) && n("pattern", "does not match pattern")), Array.isArray(t) && (e.minItems !== void 0 && t.length < e.minItems && n("minItems", `fewer than minItems ${e.minItems}`), e.maxItems !== void 0 && t.length > e.maxItems && n("maxItems", `more than maxItems ${e.maxItems}`), e.uniqueItems && new Set(t.map((o) => JSON.stringify(o))).size !== t.length && n("uniqueItems", "items not unique"), e.items && t.forEach((r, o) => I(e.items, r, `${a}[${o}]`, s))), A(t) === "object") {
+    const r = t;
+    for (const o of e.required ?? [])
+      (!(o in r) || r[o] === void 0) && n("required", "required", `${a}.${o}`);
+    if (e.properties)
+      for (const [o, m] of Object.entries(e.properties))
+        o in r && r[o] !== void 0 && I(m, r[o], `${a}.${o}`, s);
+  }
+}
+function Pt(e, t) {
+  const i = [];
+  return I(e, t, "", i), { valid: i.length === 0, errors: i.map((s) => s.message), issues: i };
+}
+const T = {
+  artifact: { type: "object", properties: { src: { type: "string" }, files: { type: "array", maxItems: 500, items: { type: "object", required: ["path"], properties: { path: { type: "string", maxLength: 1024 }, url: { type: "string" }, code: { type: "string" }, language: { type: "string", maxLength: 40 }, type: { type: "string", enum: ["html", "pdf", "image", "other"] }, additions: { type: "integer", minimum: 0 }, deletions: { type: "integer", minimum: 0 }, status: { type: "string", enum: ["added", "modified", "deleted", "renamed", "untracked"] } } } }, tab: { type: "string", enum: ["preview", "code"] }, activeFile: { type: "string", maxLength: 1024 }, displayUrl: { type: "string", maxLength: 2048 } } },
+  choice: { type: "object", required: ["options"], properties: { prompt: { type: "string" }, submitLabel: { type: "string" }, options: { type: "array", minItems: 1, items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1 }, label: { type: "string", minLength: 1 }, description: { type: "string" }, media: { type: "object", properties: { image: { type: "string" }, imageAlt: { type: "string" }, icon: { type: "string" } } }, meta: { type: "string" }, recommended: { type: "boolean" }, disabled: { type: "boolean" } } } }, dismissible: { type: "boolean" } } },
+  confirm: { type: "object", required: ["actions"], properties: { heading: { type: "string" }, body: { type: "string" }, tone: { type: "string", enum: ["default", "warning", "danger"] }, actions: { type: "array", minItems: 1, maxItems: 4, items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1 }, label: { type: "string", minLength: 1 }, style: { type: "string", enum: ["primary", "default", "destructive"] }, default: { type: "boolean" } } } }, dismissible: { type: "boolean" } } },
+  embed: { type: "object", required: ["provider"], properties: { provider: { type: "string", enum: ["youtube", "vimeo", "generic"] }, id: { type: "string", maxLength: 64, pattern: "^[A-Za-z0-9_-]+$" }, url: { type: "string" }, title: { type: "string", maxLength: 300 }, poster: { type: "string" }, start: { type: "integer", minimum: 0 }, aspectRatio: { type: "string", enum: ["16:9", "4:3", "1:1", "9:16"] } } },
+  form: { type: "object", required: ["type", "properties"], properties: { type: { const: "object" }, title: { type: "string" }, description: { type: "string" }, required: { type: "array", items: { type: "string" } }, properties: { type: "object" }, "x-kai-order": { type: "array", items: { type: "string" } }, "x-kai-inlineMax": { type: "integer", minimum: 1 }, "x-kai-submitLabel": { type: "string" }, "x-kai-dismissible": { type: "boolean" }, "x-kai-actions": { type: "array", items: { type: "object", required: ["id", "label"], properties: { id: { type: "string" }, label: { type: "string" }, variant: { enum: ["default", "ghost", "outline"] } } } } } },
+  link: { type: "object", required: ["url"], properties: { url: { type: "string" }, title: { type: "string", maxLength: 300 }, description: { type: "string", maxLength: 1e3 }, image: { type: "string" }, imageAlt: { type: "string", maxLength: 300 }, favicon: { type: "string" }, domain: { type: "string", maxLength: 253 }, siteName: { type: "string", maxLength: 200 } } },
+  tasks: { type: "object", required: ["tasks"], properties: { mode: { type: "string", enum: ["select", "progress"] }, heading: { type: "string" }, tasks: { type: "array", minItems: 1, items: { type: "object", required: ["id", "label"], properties: { id: { type: "string", minLength: 1 }, label: { type: "string", minLength: 1 }, description: { type: "string" }, checked: { type: "boolean" }, disabled: { type: "boolean" } } } }, selectAll: { type: "boolean" }, confirmLabel: { type: "string" }, allowEmpty: { type: "boolean" }, min: { type: "integer", minimum: 0 }, max: { type: "integer", minimum: 1 }, dismissible: { type: "boolean" } } }
+}, Nt = Object.freeze({
+  // hard: nothing to render
+  type: "hard",
+  required: "hard",
+  const: "hard",
+  // pins a discriminator (`form.data.type` must be `"object"`)
+  minItems: "hard",
+  // soft: content is present, bounds are not respected
+  enum: "soft",
+  // cards fall back to their default variant for an unknown value
+  maxItems: "soft",
+  minLength: "soft",
+  maxLength: "soft",
+  pattern: "soft",
+  minimum: "soft",
+  maximum: "soft",
+  exclusiveMinimum: "soft",
+  exclusiveMaximum: "soft",
+  uniqueItems: "soft"
+}), _t = "soft";
+function Dt(e) {
+  return Object.prototype.hasOwnProperty.call(T, e);
+}
+function zt(e, t) {
+  if (t && Object.prototype.hasOwnProperty.call(t, e)) {
+    const i = t[e];
+    if (i && typeof i == "object") return i;
+  }
+  return Dt(e) ? T[e] : null;
+}
+function Mt(e) {
+  const t = e.slice(0, 3).map((s) => s.message), i = e.length - t.length;
+  return t.join("; ") + (i > 0 ? `; and ${i} more` : "");
+}
+function Ut(e, t, i) {
+  const s = zt(e, i);
+  if (s === null) return null;
+  const a = Pt(s, t);
+  if (a.valid) return { ok: !0, tier: "ok", issues: [], hard: [], summary: "" };
+  const n = a.issues.map((o) => ({
+    ...o,
+    tier: Nt[o.keyword] ?? _t
+  })), r = n.filter((o) => o.tier === "hard");
+  return {
+    ok: !1,
+    tier: r.length > 0 ? "hard" : "soft",
+    issues: n,
+    hard: r,
+    summary: Mt(r.length > 0 ? r : n)
+  };
+}
+function Xt(e) {
+  return `invalid card data (${e.tier}): ${e.summary}`;
+}
+const Ft = (e) => typeof e == "object" && e !== null && !Array.isArray(e);
+function Jt(e) {
+  const t = e.map((s) => `"${s}"`).join(", "), i = e.length === 1 ? "type" : "types";
+  return [
+    `createCardRegistry: ${e.length} custom card ${i} registered with no \`schema\`: ${t}.`,
+    "  They will still RENDER (their tag/component is registered), but:",
+    "    - cardTools() skips them, so the model is never told the type exists and will never emit one;",
+    "    - registry.validate() returns null for them, so nothing checks what does arrive.",
+    "  A card type the model is never told about and that nothing validates is a silent hole.",
+    "  Fix: give each one a `schema`. If the type is populated by your own code and never by a",
+    "  model, say so with `onIncomplete: 'silent'`; use `onIncomplete: 'throw'` to make it fatal."
+  ].join(`
+`);
+}
+function Zt(e = {}) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    throw new TypeError('createCardRegistry: expected a spec object, e.g. createCardRegistry({ use: ["confirm"] })');
+  const t = j, i = e.use ?? Object.keys(t), s = i.filter((d) => !Yt(d));
+  if (s.length > 0)
+    throw new TypeError(
+      `createCardRegistry: \`use\` names ${s.length} type(s) that are not built in: ${s.map((d) => `"${d}"`).join(", ")}. The built-in types are ${Object.keys(t).join(", ")}. A card type of your own goes in \`custom\`, with its schema, not in \`use\`.`
+    );
+  const a = new Set(i), n = Object.keys(t).filter((d) => a.has(d)), r = e.custom ?? {}, o = Object.keys(r);
+  if (o.find((d) => d.trim().length === 0) !== void 0)
+    throw new TypeError("createCardRegistry: a custom card type name must be a non-empty string; it becomes `CardEnvelope.type` and the `kai_<type>` tool name.");
+  const p = {};
+  for (const d of n) p[d] = t[d];
+  const c = {}, u = {}, h = {}, b = {}, f = [];
+  for (const d of o) {
+    const l = r[d];
+    if (typeof l != "object" || l === null || Array.isArray(l))
+      throw new TypeError(`createCardRegistry: custom card type "${d}" must be an object, e.g. { schema, tag }.`);
+    Ft(l.schema) ? (p[d] = l.schema, b[d] = l.schema) : (delete p[d], f.push(d)), typeof l.tag == "string" && l.tag.length > 0 && (u[d] = l.tag), typeof l.component == "function" && (h[d] = l.component), typeof l.description == "string" && l.description.length > 0 && (c[d] = l.description);
+  }
+  if (f.length > 0) {
+    const d = e.onIncomplete ?? "warn", l = Jt(f);
+    if (d === "throw") throw new TypeError(l);
+    d !== "silent" && console.warn(l);
+  }
+  const $ = Object.freeze({ ...b });
+  return Object.freeze({
+    schemas: Object.freeze(p),
+    descriptions: Object.freeze(c),
+    tags: Object.freeze(u),
+    components: Object.freeze(h),
+    types: Object.freeze([...n, ...o]),
+    builtIn: Object.freeze(n),
+    custom: Object.freeze([...o]),
+    incomplete: Object.freeze([...f]),
+    validationSchemas: $,
+    validate: (d, l) => Ut(d, l, $)
+  });
+}
+const ei = {
+  form: "kai-form",
+  confirm: "kai-confirm",
+  tasks: "kai-tasks",
+  choice: "kai-choice",
+  link: "kai-link-preview",
+  embed: "kai-embed",
+  artifact: "kai-artifact"
+}, y = (e) => e, j = Object.freeze({
+  artifact: y(J),
+  choice: y(me),
+  confirm: y(we),
+  embed: y(Ce),
+  form: y(Be),
+  link: y(et),
+  tasks: y(ft)
+}), ti = Object.freeze({
+  "card-envelope": y(Q),
+  "card-event": y(oe),
+  "form.result": y(_e),
+  "tasks.result": y(pt)
+}), ii = Object.freeze(
+  Object.keys(j)
+);
+function Yt(e) {
+  return Object.prototype.hasOwnProperty.call(j, e);
+}
+export {
+  E as ANTHROPIC_STRICT,
+  ei as BUILTIN_CARD_TAGS,
+  kt as CARD_TOOL_DESCRIPTIONS,
+  S as KAI_TOOL_PREFIX,
+  C as OPENAI_STRICT,
+  Ot as UnsupportedCardToolSchemaError,
+  Kt as cardFromToolCall,
+  ii as cardSchemaNames,
+  j as cardSchemas,
+  v as cardTools,
+  q as cardTypeFromToolName,
+  Xt as cardValidationMessage,
+  xt as checkProviderSubset,
+  ti as contractSchemas,
+  Zt as createCardRegistry,
+  Yt as isCardSchemaName,
+  Ht as isCardTool,
+  Wt as providerSubsets,
+  Gt as toAnthropicTools,
+  Qt as toJsonSchemaTools,
+  Vt as toOpenAITools,
+  gt as toolNameForCardType,
+  Ut as validateCardData
+};