@heroui/agent 0.2.0-beta.1

package/dist/contracts.js

@@ -0,0 +1,2325 @@
+// src/contracts/attachments.ts
+var HEROUI_AGENT_MAX_ATTACHMENTS = 5;
+var HEROUI_AGENT_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+var HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE = {
+  "application/json": "json",
+  "application/pdf": "pdf",
+  "image/gif": "gif",
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/webp": "webp",
+  "text/csv": "csv",
+  "text/markdown": "md",
+  "text/plain": "txt",
+  "text/tab-separated-values": "tsv"
+};
+var HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES = Object.freeze(
+  Object.keys(
+    HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE
+  )
+);
+var HEROUI_AGENT_ATTACHMENT_ACCEPT = HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES.join(",");
+var HEROUI_AGENT_ATTACHMENT_CONTENT_TYPE_SET = new Set(
+  HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES
+);
+var HEROUI_AGENT_TEXT_ATTACHMENT_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "application/json",
+  "text/csv",
+  "text/markdown",
+  "text/plain",
+  "text/tab-separated-values"
+]);
+function isHeroUIAgentAttachmentContentType(value) {
+  return HEROUI_AGENT_ATTACHMENT_CONTENT_TYPE_SET.has(value.trim().toLowerCase());
+}
+
+// src/contracts/appearance.ts
+var HEROUI_AGENT_REMOTE_CONFIG_VERSION = 1;
+var INVALID = Symbol("invalid");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "string" ? value : INVALID;
+}
+function optionalBoolean(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "boolean" ? value : INVALID;
+}
+function optionalNumber(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" && Number.isFinite(value) ? value : INVALID;
+}
+function optionalEnum(allowed) {
+  return (value) => {
+    if (value === void 0) return void 0;
+    return typeof value === "string" && allowed.includes(value) ? value : INVALID;
+  };
+}
+function optionalThemeColor(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return INVALID;
+  const dark = optionalString(value["dark"]);
+  const light = optionalString(value["light"]);
+  if (dark === INVALID || light === INVALID) return INVALID;
+  return { ...dark === void 0 ? {} : { dark }, ...light === void 0 ? {} : { light } };
+}
+function optionalStringRecord(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) return INVALID;
+  const record = {};
+  for (const [key2, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") return INVALID;
+    record[key2] = entry;
+  }
+  return record;
+}
+function optionalStringArray(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) return INVALID;
+  return value;
+}
+function shape(value, validators2) {
+  if (value === void 0) return INVALID;
+  if (!isRecord(value)) return INVALID;
+  const result = {};
+  for (const [key2, validate] of Object.entries(validators2)) {
+    const parsed = validate(value[key2]);
+    if (parsed === INVALID) return INVALID;
+    if (parsed !== void 0) result[key2] = parsed;
+  }
+  return result;
+}
+function group(parsed) {
+  return parsed === INVALID ? void 0 : parsed;
+}
+var COLOR_KEYS = [
+  "accent",
+  "background",
+  "foreground",
+  "overlay",
+  "surface",
+  "surfaceSecondary",
+  "tooltip"
+];
+function parseAppearance(value) {
+  return shape(value, {
+    launcher: (launcher) => launcher === void 0 ? void 0 : shape(launcher, {
+      background: optionalThemeColor,
+      icon: optionalString,
+      position: optionalEnum(["bottom-left", "bottom-right"]),
+      style: optionalStringRecord
+    }),
+    panel: (panel) => panel === void 0 ? void 0 : shape(panel, {
+      expandable: optionalBoolean,
+      expanded: optionalBoolean,
+      initialHeight: (entry) => entry === void 0 || typeof entry === "string" ? entry : optionalNumber(entry),
+      initialWidth: (entry) => entry === void 0 || typeof entry === "string" ? entry : optionalNumber(entry)
+    }),
+    theme: (theme) => theme === void 0 ? void 0 : shape(theme, {
+      colorScheme: optionalEnum(["dark", "light", "system"]),
+      colors: (colors) => colors === void 0 ? void 0 : shape(
+        colors,
+        Object.fromEntries(COLOR_KEYS.map((key2) => [key2, optionalThemeColor]))
+      ),
+      designTheme: optionalEnum(["base", "brutalism", "glass", "mouve"]),
+      radius: optionalEnum(["pill", "round", "sharp", "soft"]),
+      typography: (typography) => typography === void 0 ? void 0 : shape(typography, { baseSize: optionalNumber, fontFamily: optionalString })
+    }),
+    viewMode: optionalEnum(["floating", "sidebar"])
+  });
+}
+function parseComposer(value) {
+  return shape(value, {
+    attachments: (attachments) => {
+      if (attachments === void 0 || attachments === false) return attachments;
+      if (!Array.isArray(attachments)) return INVALID;
+      const types = attachments.filter(
+        (entry) => typeof entry === "string" && isHeroUIAgentAttachmentContentType(entry)
+      );
+      return types.length === attachments.length ? types : INVALID;
+    },
+    defaultModel: optionalString,
+    dictation: optionalBoolean,
+    disclaimer: (disclaimer) => disclaimer === false ? false : optionalString(disclaimer),
+    modelPicker: optionalBoolean,
+    placeholder: optionalString
+  });
+}
+function parseMarkdown(value) {
+  return shape(value, {
+    animated: (animated) => {
+      if (animated === void 0 || animated === false) return animated;
+      if (!isRecord(animated)) return INVALID;
+      const animation = optionalEnum(["blurIn", "fadeIn", "slideUp"])(
+        animated["animation"]
+      );
+      if (animation === INVALID || animation === void 0) return INVALID;
+      return { ...animated, animation };
+    },
+    caret: (caret) => caret === false ? false : optionalEnum(["block", "circle"])(caret)
+  });
+}
+function parseResponseActions(value) {
+  if (value === void 0 || value === false) return value;
+  if (!Array.isArray(value)) return INVALID;
+  const allowed = ["copy", "feedback", "retry"];
+  const actions = value.filter(
+    (entry) => typeof entry === "string" && allowed.includes(entry)
+  );
+  return actions.length === value.length ? actions : INVALID;
+}
+function parseAgentRemoteConfig(value) {
+  if (!isRecord(value)) return null;
+  if (value["version"] !== HEROUI_AGENT_REMOTE_CONFIG_VERSION) return null;
+  const revision = value["revision"];
+  if (typeof revision !== "string" || !revision) return null;
+  const appearance = group(parseAppearance(value["appearance"]));
+  const capabilities = group(
+    shape(value["capabilities"], {
+      imageSearch: optionalBoolean,
+      webSearch: optionalBoolean
+    })
+  );
+  const composer = group(parseComposer(value["composer"]));
+  const markdown = group(parseMarkdown(value["markdown"]));
+  const permissions = group(
+    shape(value["permissions"], {
+      defaultMode: optionalEnum(["ask", "auto", "full"]),
+      showPicker: optionalBoolean
+    })
+  );
+  const responseActions = group(parseResponseActions(value["responseActions"]));
+  const startScreen = group(
+    shape(value["startScreen"], {
+      greeting: optionalString,
+      promptShortcuts: optionalBoolean,
+      prompts: optionalStringArray
+    })
+  );
+  const webfont = group(
+    shape(value["webfont"], {
+      familyName: (familyName) => typeof familyName === "string" && familyName ? familyName : INVALID,
+      fontFaceUrl: optionalString,
+      stylesheetUrl: optionalString
+    })
+  );
+  return {
+    ...appearance ? { appearance } : {},
+    ...capabilities ? { capabilities } : {},
+    ...composer ? { composer } : {},
+    ...markdown ? { markdown } : {},
+    ...permissions ? { permissions } : {},
+    ...responseActions === void 0 ? {} : { responseActions },
+    ...startScreen ? { startScreen } : {},
+    ...webfont ? { webfont } : {},
+    revision,
+    version: HEROUI_AGENT_REMOTE_CONFIG_VERSION
+  };
+}
+
+// ../agent-ui/src/categories.ts
+var COMPONENT_CATEGORY_BY_KIND = {
+  accordion: "display-information",
+  "action-group": "actions",
+  "area-chart": "data-visualization",
+  "bar-chart": "data-visualization",
+  callout: "display-information",
+  "channel-message": "display-information",
+  "code-block": "display-information",
+  "comparison-list": "data-visualization",
+  "composed-chart": "data-visualization",
+  "create-event": "display-information",
+  "data-table": "data-visualization",
+  diagram: "display-information",
+  "donut-chart": "data-visualization",
+  "enable-notification": "display-information",
+  "event-session": "display-information",
+  "flight-tracker": "display-information",
+  followup: "actions",
+  form: "form-elements",
+  heatmap: "data-visualization",
+  image: "display-information",
+  "kpi-grid": "data-visualization",
+  "line-chart": "data-visualization",
+  list: "display-information",
+  "list-block": "display-information",
+  map: "display-information",
+  "meter-list": "data-visualization",
+  "metric-grid": "data-visualization",
+  "pie-chart": "data-visualization",
+  "player-card": "display-information",
+  playlist: "display-information",
+  "product-card": "display-information",
+  "product-signals": "data-visualization",
+  "purchase-complete": "display-information",
+  "purchase-items": "display-information",
+  "radar-chart": "data-visualization",
+  "radial-chart": "data-visualization",
+  "record-card": "display-information",
+  "ride-status": "display-information",
+  "sankey-chart": "data-visualization",
+  "scatter-chart": "data-visualization",
+  steps: "display-information",
+  "switch-group": "form-elements",
+  tabs: "display-information",
+  "tag-list": "display-information",
+  text: "display-information",
+  "toggle-group": "form-elements",
+  "view-event": "display-information",
+  "weather-current": "display-information",
+  "weather-forecast": "display-information"
+};
+
+// ../agent-ui/src/contracts/components.ts
+import { z } from "zod";
+var agentIconNames = [
+  "activity",
+  "alert",
+  "briefcase",
+  "calendar",
+  "chart",
+  "check",
+  "clock",
+  "code",
+  "credit-card",
+  "database",
+  "device-desktop",
+  "device-mobile",
+  "document",
+  "dollar",
+  "flag",
+  "globe",
+  "heart",
+  "home",
+  "info",
+  "lightning",
+  "location",
+  "mail",
+  "percent",
+  "person",
+  "question",
+  "receipt",
+  "rocket",
+  "route",
+  "search",
+  "shopping-bag",
+  "speedometer",
+  "star",
+  "tag",
+  "target",
+  "users"
+];
+var weatherConditions = [
+  "clear",
+  "partly-cloudy",
+  "cloudy",
+  "fog",
+  "drizzle",
+  "rain",
+  "snow",
+  "thunderstorm",
+  "windy",
+  "unknown"
+];
+var title = z.string().trim().min(1).max(120);
+var shortText = z.string().trim().min(1).max(320);
+var content = z.string().trim().min(1).max(1e4);
+var key = z.string().trim().min(1).max(80);
+var id = z.string().trim().min(1).max(100);
+var date = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+var time = z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d)?$/);
+var datumValue = z.union([z.string().max(500), z.number(), z.boolean(), z.null()]);
+var datum = z.record(z.string().max(80), datumValue);
+var base = z.object({ description: shortText.optional(), id, title });
+var cardComponentVariantSchema = z.enum(["outline", "plain", "surface", "surface-secondary", "surface-tertiary", "widget"]).describe(
+  "Card hierarchy: surface for the primary standalone group; surface-secondary for supporting information; surface-tertiary for one featured or emphasized group; outline for equal peers and comparisons; plain for a structural section already separated by surrounding layout; widget for a compact interactive group with actions or controls."
+);
+var recordCardLayoutSchema = z.enum(["compact", "details", "media"]).describe(
+  "Record information layout: details for a full labeled fact set; compact for a brief summary or repeated peer cards; media for an image-led product, place, person, or event and only when an image is available."
+);
+var numberFormatSchema = z.discriminatedUnion("style", [
+  z.object({ compact: z.boolean().optional(), style: z.literal("number") }),
+  z.object({
+    maximumFractionDigits: z.number().int().min(0).max(4).optional(),
+    style: z.literal("percent")
+  }),
+  z.object({
+    compact: z.boolean().optional(),
+    currency: z.string().regex(/^[A-Z]{3}$/),
+    style: z.literal("currency")
+  })
+]);
+var chartColorSchema = z.enum([
+  "accent",
+  "chart-1",
+  "chart-2",
+  "chart-3",
+  "chart-4",
+  "chart-5",
+  "danger",
+  "default",
+  "success",
+  "warning"
+]);
+var chartColors = z.record(z.string().trim().min(1).max(80), chartColorSchema).refine((colors) => Object.keys(colors).length <= 50, "At most 50 category colors are allowed");
+var series = z.object({
+  color: chartColorSchema.optional(),
+  dataKey: key,
+  format: numberFormatSchema.optional(),
+  label: shortText
+});
+var composedSeries = series.extend({
+  axis: z.enum(["left", "right"]).optional(),
+  stacked: z.boolean().optional(),
+  type: z.enum(["area", "bar", "line"])
+});
+var cartesianRange = z.object({
+  id,
+  label: shortText,
+  maxItems: z.number().int().min(1).max(200).optional()
+});
+var cartesian = base.extend({
+  data: z.array(datum).min(1).max(200),
+  defaultRangeId: id.optional(),
+  ranges: z.array(cartesianRange).min(2).max(8).optional(),
+  series: z.array(series).min(1).max(5),
+  showSummary: z.boolean().optional(),
+  xKey: key
+});
+var proportional = base.extend({
+  colors: chartColors.optional(),
+  data: z.array(datum).min(1).max(50),
+  format: numberFormatSchema.optional(),
+  labelKey: key,
+  valueKey: key
+});
+var scatter = base.extend({
+  colors: chartColors.optional(),
+  data: z.array(datum).min(1).max(200),
+  format: numberFormatSchema.optional(),
+  groupKey: key.optional(),
+  kind: z.literal("scatter-chart"),
+  labelKey: key.optional(),
+  sizeKey: key.optional(),
+  xKey: key,
+  yKey: key
+});
+var heatmap = base.extend({
+  color: chartColorSchema.optional(),
+  data: z.array(datum).min(1).max(400),
+  format: numberFormatSchema.optional(),
+  kind: z.literal("heatmap"),
+  valueKey: key,
+  xKey: key,
+  yKey: key
+});
+var option = z.object({ label: shortText, value: key });
+var formDateRange = z.object({ end: date, start: date }).refine((range) => range.start <= range.end, "The start date must not be after the end date");
+var fieldBase = {
+  description: shortText.optional(),
+  label: shortText,
+  name: key,
+  required: z.boolean().optional()
+};
+var formField = z.discriminatedUnion("kind", [
+  z.object({
+    ...fieldBase,
+    defaultValue: z.string().max(500).optional(),
+    inputType: z.enum(["email", "number", "password", "search", "tel", "text", "url"]).optional(),
+    kind: z.literal("input"),
+    placeholder: z.string().max(160).optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.string().max(2e3).optional(),
+    kind: z.literal("textarea"),
+    placeholder: z.string().max(160).optional(),
+    rows: z.number().int().min(2).max(12).optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: key.optional(),
+    kind: z.literal("select"),
+    options: z.array(option).min(1).max(30),
+    placeholder: z.string().max(160).optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: key.optional(),
+    kind: z.literal("radio-group"),
+    options: z.array(option).min(1).max(12),
+    placeholder: z.string().max(160).optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.array(key).max(20).optional(),
+    kind: z.literal("checkbox-group"),
+    options: z.array(option).min(1).max(20)
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.array(key).max(50).optional(),
+    kind: z.literal("combobox"),
+    options: z.array(option.extend({ description: z.string().trim().min(1).max(120).optional() })).min(1).max(200).describe(
+      "Prefer this over select once there are more options than someone would scan \u2014 it filters as they type. Values must be unique."
+    ),
+    placeholder: z.string().max(160).optional(),
+    selectionMode: z.enum(["multiple", "single"]).optional()
+  }).superRefine((field, ctx) => {
+    const values = new Set(field.options.map((entry) => entry.value));
+    if (values.size !== field.options.length) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Combobox option values must be unique",
+        path: ["options"]
+      });
+    }
+    if ((field.selectionMode ?? "single") === "single" && (field.defaultValue?.length ?? 0) > 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: "A single-selection combobox takes at most one default value",
+        path: ["defaultValue"]
+      });
+    }
+    if (field.defaultValue?.some((value) => !values.has(value))) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Every combobox default value must be one of the options",
+        path: ["defaultValue"]
+      });
+    }
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.number().optional(),
+    kind: z.literal("slider"),
+    max: z.number(),
+    min: z.number(),
+    step: z.number().positive().optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.number().optional(),
+    format: numberFormatSchema.optional(),
+    kind: z.literal("number"),
+    max: z.number().optional(),
+    min: z.number().optional(),
+    placeholder: z.string().max(160).optional(),
+    step: z.number().positive().optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: z.boolean().optional(),
+    kind: z.literal("switch")
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: date.optional(),
+    kind: z.literal("date-picker"),
+    max: date.optional(),
+    min: date.optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: formDateRange.optional(),
+    kind: z.literal("date-range-picker"),
+    max: date.optional(),
+    min: date.optional()
+  }),
+  z.object({
+    ...fieldBase,
+    defaultValue: time.optional(),
+    hourCycle: z.union([z.literal(12), z.literal(24)]).optional(),
+    kind: z.literal("time-field"),
+    max: time.optional(),
+    min: time.optional()
+  })
+]);
+var actionVariant = z.enum(["danger", "outline", "primary", "secondary", "tertiary"]);
+var agentIconSchema = z.enum(agentIconNames);
+var actionToolCall = z.object({
+  arguments: z.record(z.string().max(80), z.unknown()).refine(
+    (value) => JSON.stringify(value).length <= 4096,
+    "Tool call arguments must serialize to at most 4KB of JSON"
+  ),
+  name: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/)
+});
+var action = z.object({
+  id,
+  label: shortText,
+  prompt: z.string().trim().min(1).max(2e3).optional(),
+  toolCall: actionToolCall.optional(),
+  variant: actionVariant.optional()
+});
+var mapCoordinate = z.object({
+  latitude: z.number().finite().min(-85.051129).max(85.051129),
+  longitude: z.number().finite().min(-180).max(180)
+});
+var httpUrl = z.string().trim().min(1).max(2e3).refine(
+  (value) => {
+    try {
+      const url = new URL(value);
+      return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
+    } catch {
+      return false;
+    }
+  },
+  { message: "URL must use HTTP or HTTPS and cannot include credentials" }
+);
+var contactUrl = z.string().trim().min(1).max(2e3).refine(
+  (value) => {
+    try {
+      const url = new URL(value);
+      return ["http:", "https:", "mailto:", "tel:"].includes(url.protocol) && !url.username && !url.password;
+    } catch {
+      return false;
+    }
+  },
+  { message: "Link must use HTTP, HTTPS, mailto, or tel and cannot include credentials" }
+);
+var mapActionBase = { id, label: shortText, variant: actionVariant.optional() };
+var telephoneUrl = z.string().trim().min(5).max(2e3).refine(
+  (value) => /^tel:\+?[0-9().\-\s]+$/.test(value) && /\d/.test(value.slice(4)),
+  "Phone links must use the tel: scheme and contain a phone number"
+);
+var mapLocationAction = z.discriminatedUnion("kind", [
+  z.object({ ...mapActionBase, href: telephoneUrl, kind: z.literal("call") }),
+  z.object({ ...mapActionBase, href: httpUrl, kind: z.literal("directions") }),
+  z.object({ ...mapActionBase, href: contactUrl, kind: z.literal("other") }),
+  z.object({ ...mapActionBase, href: httpUrl, kind: z.literal("website") })
+]);
+var mapLocation = mapCoordinate.extend({
+  actions: z.array(mapLocationAction).max(4).optional(),
+  address: shortText.optional(),
+  category: z.string().trim().min(1).max(100).optional(),
+  id,
+  images: z.array(z.object({ alt: shortText, src: httpUrl })).max(4).optional().describe(
+    "Prefer one representative image per location when a trusted tool or web image search returns one. The first image becomes the result-card thumbnail; initials are the fallback."
+  ),
+  notes: z.string().trim().min(1).max(2e3).optional(),
+  rating: z.number().finite().min(0).max(5).optional(),
+  relevance: z.number().finite().min(0).max(1).optional(),
+  reviewCount: z.number().int().nonnegative().max(1e9).optional(),
+  title: shortText
+});
+var displayImageSrc = z.string().trim().min(1).max(2e3).refine(
+  (value) => {
+    if (value.startsWith("/")) return !value.startsWith("//");
+    try {
+      const url = new URL(value);
+      return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
+    } catch {
+      return false;
+    }
+  },
+  { message: "Image sources must be HTTP(S) URLs or root-relative paths" }
+);
+var agentUIImage = z.object({
+  alt: shortText,
+  src: displayImageSrc.refine(
+    (value) => !value.split(/[?#]/, 1)[0]?.toLowerCase().endsWith(".svg"),
+    "Response-composition images must be raster images"
+  )
+});
+var currency = z.string().regex(/^[A-Z]{3}$/);
+var amount = z.object({
+  amount: z.number().finite().nonnegative().max(1e9),
+  currency
+});
+var weatherConditionSchema = z.enum(weatherConditions);
+var weatherUnit = z.enum(["celsius", "fahrenheit"]);
+var endpoint = z.object({
+  label: shortText,
+  status: shortText.optional(),
+  time: z.string().trim().min(1).max(80)
+});
+var recordTone = z.enum(["accent", "danger", "default", "muted", "success", "warning"]);
+var productCardItem = z.object({
+  actions: z.array(action).max(3).optional(),
+  badge: z.object({ label: shortText, tone: recordTone.optional() }).optional(),
+  description: shortText.optional(),
+  id,
+  image: z.object({ alt: shortText, src: displayImageSrc }),
+  meta: z.string().trim().min(1).max(160).optional(),
+  name: shortText,
+  price: z.object({
+    amount: z.number().finite().nonnegative().max(1e9),
+    currency: currency.optional()
+  }),
+  rating: z.object({
+    count: z.number().int().nonnegative().max(1e9).optional(),
+    value: z.number().finite().min(0).max(5)
+  }).optional()
+});
+var meterTone = z.enum(["accent", "danger", "default", "success", "warning"]);
+var meterItem = z.object({
+  description: shortText.optional(),
+  format: numberFormatSchema.optional(),
+  id,
+  label: shortText,
+  max: z.number().optional(),
+  min: z.number().optional(),
+  tone: meterTone.optional(),
+  value: z.number()
+}).superRefine((item, ctx) => {
+  const min = item.min ?? 0;
+  const max = item.max ?? (item.format?.style === "percent" ? 1 : 100);
+  if (max <= min) {
+    ctx.addIssue({ code: "custom", message: "Meter max must be greater than min" });
+  }
+  if (item.value < min || item.value > max) {
+    ctx.addIssue({ code: "custom", message: "Meter value must be within its min/max range" });
+  }
+});
+var validators = {
+  accordion: base.extend({
+    kind: z.literal("accordion"),
+    sections: z.array(z.object({ content, defaultOpen: z.boolean().optional(), id, title: shortText })).min(1).max(12)
+  }),
+  actions: base.extend({
+    actions: z.array(action).min(1).max(8),
+    kind: z.literal("action-group"),
+    orientation: z.enum(["horizontal", "vertical"]).optional()
+  }),
+  area: cartesian.extend({ kind: z.literal("area-chart"), stacked: z.boolean().optional() }),
+  bar: cartesian.extend({
+    kind: z.literal("bar-chart"),
+    layout: z.enum(["horizontal", "vertical"]).optional(),
+    stacked: z.boolean().optional()
+  }),
+  callout: base.extend({
+    content,
+    icon: agentIconSchema.optional(),
+    kind: z.literal("callout"),
+    tone: z.enum(["accent", "danger", "neutral", "success", "warning"]).optional()
+  }),
+  channelMessage: base.extend({
+    attachments: z.array(z.object({ id, image: agentUIImage.optional(), name: shortText })).max(8).optional(),
+    author: z.object({ image: agentUIImage.optional(), name: shortText }),
+    channel: shortText,
+    content,
+    kind: z.literal("channel-message"),
+    timestamp: z.string().trim().min(1).max(80)
+  }),
+  code: base.extend({
+    code: z.string().min(1).max(2e4),
+    kind: z.literal("code-block"),
+    language: z.string().trim().max(40).optional()
+  }),
+  comparison: base.extend({
+    items: z.array(
+      z.object({
+        change: z.number().optional(),
+        format: numberFormatSchema.optional(),
+        label: shortText,
+        note: z.string().trim().max(180).optional(),
+        value: z.number()
+      })
+    ).min(1).max(12),
+    kind: z.literal("comparison-list")
+  }),
+  composed: cartesian.extend({
+    kind: z.literal("composed-chart"),
+    series: z.array(composedSeries).min(2).max(5)
+  }),
+  createEvent: base.extend({
+    actions: z.array(action).max(2).optional(),
+    date: z.object({
+      day: z.number().int().min(1).max(31),
+      weekday: z.string().trim().min(1).max(20)
+    }),
+    events: z.array(
+      z.object({
+        id,
+        status: z.enum(["existing", "proposed"]).optional(),
+        time: z.string().trim().min(1).max(80),
+        title: shortText,
+        tone: recordTone.optional()
+      })
+    ).min(1).max(12),
+    kind: z.literal("create-event")
+  }),
+  diagram: base.extend({
+    chart: z.string().trim().min(1).max(4e3).describe(
+      'Mermaid source. Pick the diagram type from the relationship: "flowchart LR" for a process or decision path, "sequenceDiagram" for an exchange between parties over time, "erDiagram" for how records relate, "stateDiagram-v2" for the states something moves between. Example: "flowchart LR\\n  A[Order placed] --> B{In stock?}\\n  B -- yes --> C[Ship]\\n  B -- no --> D[Backorder]". Never include HTML, script tags, or click directives.'
+    ),
+    kind: z.literal("diagram")
+  }).superRefine((component, ctx) => {
+    const forbidden = /<\s*script|javascript:|^\s*click\s+\S/im;
+    if (forbidden.test(component.chart)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Diagram source cannot contain HTML, script URLs, or click directives",
+        path: ["chart"]
+      });
+    }
+  }),
+  donut: proportional.extend({ kind: z.literal("donut-chart") }),
+  enableNotification: base.extend({
+    actions: z.tuple([action, action]),
+    kind: z.literal("enable-notification")
+  }),
+  eventSession: base.extend({
+    action: action.optional(),
+    eyebrow: z.string().trim().min(1).max(100).optional(),
+    kind: z.literal("event-session"),
+    location: shortText,
+    speakers: z.array(z.object({ image: agentUIImage.optional(), name: shortText, role: shortText })).max(8),
+    time: z.string().trim().min(1).max(80)
+  }),
+  flightTracker: base.extend({
+    airline: z.object({ logo: agentUIImage.optional(), name: shortText }),
+    date: z.string().trim().min(1).max(80),
+    destination: endpoint,
+    flightNumber: z.string().trim().min(1).max(40),
+    kind: z.literal("flight-tracker"),
+    origin: endpoint,
+    progress: z.number().finite().min(0).max(100).optional()
+  }),
+  followup: base.extend({
+    kind: z.literal("followup"),
+    prompts: z.array(z.object({ id, label: shortText, prompt: content })).min(1).max(8)
+  }),
+  form: base.extend({
+    actions: z.array(action).min(1).max(4),
+    fields: z.array(formField).min(1).max(20),
+    kind: z.literal("form")
+  }),
+  heatmap,
+  image: base.extend({
+    images: z.array(
+      z.object({
+        alt: shortText,
+        aspectRatio: z.enum(["landscape", "portrait", "square", "wide"]).optional(),
+        caption: shortText.optional(),
+        src: displayImageSrc
+      })
+    ).min(1).max(6),
+    kind: z.literal("image"),
+    variant: z.enum(["grid", "horizontal"]).optional().describe("Use horizontal for a swipeable gallery in narrow chat interfaces.")
+  }),
+  kpiGrid: base.extend({
+    kind: z.literal("kpi-grid"),
+    metrics: z.array(
+      z.object({
+        change: z.number().optional(),
+        color: chartColorSchema.optional(),
+        format: numberFormatSchema.optional(),
+        icon: agentIconSchema.optional(),
+        label: shortText,
+        trend: z.array(z.number().finite()).min(2).max(60).describe(
+          "The values behind this KPI, oldest to newest, drawn as a sparkline. The last point should agree with value."
+        ),
+        value: z.number()
+      })
+    ).min(1).max(4)
+  }),
+  line: cartesian.extend({ kind: z.literal("line-chart") }),
+  list: base.extend({
+    items: z.array(
+      z.object({
+        checked: z.boolean().optional(),
+        children: z.array(shortText).max(8).optional(),
+        id,
+        text: shortText
+      })
+    ).min(1).max(30),
+    kind: z.literal("list"),
+    style: z.enum(["bulleted", "checklist", "numbered"]).optional()
+  }),
+  listBlock: base.extend({
+    items: z.array(
+      z.object({
+        description: shortText.optional(),
+        icon: agentIconSchema.optional(),
+        id,
+        imageAlt: shortText.optional(),
+        imageUrl: displayImageSrc.optional(),
+        meta: z.string().trim().max(100).optional(),
+        rating: z.number().min(0).max(5).optional(),
+        title: shortText
+      })
+    ).min(1).max(20),
+    kind: z.literal("list-block")
+  }),
+  map: base.extend({
+    initialLocationId: id.optional(),
+    kind: z.literal("map"),
+    locations: z.array(mapLocation).min(1).max(12),
+    viewport: z.object({ center: mapCoordinate, zoom: z.number().int().min(1).max(18) }).optional()
+  }).superRefine((map, ctx) => {
+    const locationIds = /* @__PURE__ */ new Set();
+    for (const [index, location] of map.locations.entries()) {
+      if (locationIds.has(location.id)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate map location id "${location.id}"`,
+          path: ["locations", index, "id"]
+        });
+      }
+      locationIds.add(location.id);
+      const actionIds = /* @__PURE__ */ new Set();
+      for (const [actionIndex, action2] of (location.actions ?? []).entries()) {
+        if (actionIds.has(action2.id)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `Duplicate action id "${action2.id}" for map location "${location.id}"`,
+            path: ["locations", index, "actions", actionIndex, "id"]
+          });
+        }
+        actionIds.add(action2.id);
+      }
+    }
+    if (map.initialLocationId && !locationIds.has(map.initialLocationId)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "The initial map location must reference one of the locations",
+        path: ["initialLocationId"]
+      });
+    }
+  }).describe(
+    "A ranked, map-synchronized set of places or professionals. Coordinates and listing facts must come from tools or user data; never invent them."
+  ),
+  meterList: base.extend({
+    items: z.array(meterItem).min(1).max(8),
+    kind: z.literal("meter-list")
+  }),
+  metricGrid: base.extend({
+    kind: z.literal("metric-grid"),
+    metrics: z.array(
+      z.object({
+        change: z.number().optional(),
+        format: numberFormatSchema.optional(),
+        icon: agentIconSchema.optional(),
+        label: shortText,
+        value: z.number()
+      })
+    ).min(1).max(4)
+  }),
+  pie: proportional.extend({ kind: z.literal("pie-chart") }),
+  playerCard: base.extend({
+    backgroundImage: agentUIImage.optional(),
+    jerseyNumber: z.string().trim().min(1).max(20).optional(),
+    kind: z.literal("player-card"),
+    playerName: shortText,
+    stats: z.array(
+      z.object({
+        label: z.string().trim().min(1).max(40),
+        value: z.union([z.string().trim().min(1).max(80), z.number().finite()])
+      })
+    ).min(1).max(8)
+  }),
+  playlist: base.extend({
+    actions: z.array(action).max(2).optional(),
+    cover: agentUIImage.optional(),
+    kind: z.literal("playlist"),
+    tracks: z.array(
+      z.object({
+        action: action.optional(),
+        artist: shortText,
+        id,
+        image: agentUIImage.optional(),
+        title: shortText
+      })
+    ).min(1).max(20)
+  }),
+  productCard: base.extend({
+    actions: z.array(action).max(3).optional(),
+    kind: z.literal("product-card"),
+    products: z.array(productCardItem).min(1).max(8),
+    variant: cardComponentVariantSchema.optional()
+  }).superRefine((card, ctx) => {
+    const productIds = /* @__PURE__ */ new Set();
+    for (const [index, item] of card.products.entries()) {
+      if (productIds.has(item.id)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate product id "${item.id}"`,
+          path: ["products", index, "id"]
+        });
+      }
+      productIds.add(item.id);
+    }
+  }).describe(
+    "A commerce product presentation: one product renders an image-led spotlight, several render a store-style grid. Product facts (id, name, image, price, rating, availability) must come from tools or user data; never invent them."
+  ),
+  purchaseComplete: base.extend({
+    action: action.optional(),
+    details: z.array(z.object({ label: shortText, value: shortText })).max(8),
+    kind: z.literal("purchase-complete"),
+    paid: amount.optional(),
+    product: z.object({
+      description: shortText.optional(),
+      image: agentUIImage.optional(),
+      name: shortText
+    })
+  }),
+  purchaseItems: base.extend({
+    actions: z.array(action).max(3).optional(),
+    currency,
+    items: z.array(
+      z.object({
+        description: shortText.optional(),
+        id,
+        image: agentUIImage.optional(),
+        name: shortText,
+        price: z.number().finite().nonnegative().max(1e9).optional(),
+        quantity: z.number().int().positive().max(1e4).optional()
+      })
+    ).min(1).max(20),
+    kind: z.literal("purchase-items"),
+    totals: z.array(
+      z.object({
+        amount: z.number().finite().nonnegative().max(1e9),
+        emphasis: z.boolean().optional(),
+        label: shortText
+      })
+    ).min(1).max(8)
+  }),
+  radar: base.extend({
+    angleKey: key,
+    data: z.array(datum).min(3).max(50),
+    kind: z.literal("radar-chart"),
+    series: z.array(series).min(1).max(5)
+  }),
+  radial: proportional.extend({
+    endAngle: z.number().min(-360).max(360).optional(),
+    kind: z.literal("radial-chart"),
+    maxValue: z.number().positive().optional(),
+    startAngle: z.number().min(-360).max(360).optional()
+  }),
+  recordCard: base.extend({
+    actions: z.array(action).max(4).optional(),
+    eyebrow: z.string().trim().max(100).optional(),
+    fields: z.array(
+      z.object({
+        icon: agentIconSchema.optional(),
+        label: shortText,
+        tone: recordTone.optional(),
+        value: z.string().trim().min(1).max(500)
+      })
+    ).max(12),
+    image: z.object({ alt: shortText, src: displayImageSrc }).optional(),
+    kind: z.literal("record-card"),
+    layout: recordCardLayoutSchema.optional(),
+    status: z.object({
+      label: shortText,
+      tone: recordTone.optional()
+    }).optional(),
+    variant: cardComponentVariantSchema.optional()
+  }).superRefine((card, ctx) => {
+    if (card.layout === "media" && !card.image) {
+      ctx.addIssue({
+        code: "custom",
+        message: "The media record layout requires an image",
+        path: ["image"]
+      });
+    }
+    if (card.layout === "compact" && card.fields.length > 4) {
+      ctx.addIssue({
+        code: "custom",
+        message: "The compact record layout supports at most four fields",
+        path: ["fields"]
+      });
+    }
+  }),
+  rideStatus: base.extend({
+    driver: z.object({ image: agentUIImage.optional(), name: shortText }),
+    eta: z.string().trim().min(1).max(80),
+    kind: z.literal("ride-status"),
+    pickup: shortText
+  }),
+  sankey: base.extend({
+    format: numberFormatSchema.optional(),
+    kind: z.literal("sankey-chart"),
+    links: z.array(z.object({ source: id, target: id, value: z.number().positive() })).min(1).max(100),
+    nodes: z.array(z.object({ id, label: shortText })).min(2).max(40)
+  }),
+  scatter,
+  steps: base.extend({
+    kind: z.literal("steps"),
+    steps: z.array(
+      z.object({
+        content: shortText.optional(),
+        icon: agentIconSchema.optional(),
+        id,
+        image: agentUIImage.optional().describe(
+          "A representative raster image for this step. Prefer this over icon for place itineraries when a trusted image URL is available."
+        ),
+        meta: z.string().trim().max(100).optional(),
+        progress: z.number().min(0).max(100).optional(),
+        status: z.enum([
+          "blocked",
+          "cancelled",
+          "completed",
+          "failed",
+          "in-progress",
+          "pending",
+          "complete",
+          "current",
+          "upcoming"
+        ]).optional(),
+        timestamp: z.string().trim().max(100).optional(),
+        title: shortText
+      })
+    ).min(1).max(12),
+    variant: z.enum(["steps", "timeline"]).optional()
+  }),
+  switches: base.extend({
+    items: z.array(
+      z.object({
+        defaultSelected: z.boolean().optional(),
+        description: shortText.optional(),
+        id,
+        label: shortText
+      })
+    ).min(1).max(20),
+    kind: z.literal("switch-group")
+  }),
+  table: base.extend({
+    columns: z.array(z.object({ format: numberFormatSchema.optional(), key, label: shortText })).min(1).max(12),
+    filterable: z.boolean().optional(),
+    kind: z.literal("data-table"),
+    rows: z.array(datum).max(200),
+    variant: z.enum(["primary", "secondary"]).optional()
+  }),
+  tabs: base.extend({
+    defaultValue: id.optional(),
+    kind: z.literal("tabs"),
+    tabs: z.array(
+      z.union([
+        z.object({
+          children: z.never().optional(),
+          content,
+          id,
+          label: shortText
+        }),
+        z.object({
+          children: z.array(z.lazy(() => agentUINodeSchema)).min(1).max(12),
+          content: z.never().optional(),
+          id,
+          label: shortText
+        })
+      ])
+    ).min(1).max(10),
+    variant: z.enum(["primary", "secondary"]).optional()
+  }),
+  tags: base.extend({ kind: z.literal("tag-list"), tags: z.array(shortText).min(1).max(30) }),
+  text: base.extend({
+    content,
+    kind: z.literal("text"),
+    variant: z.enum(["card", "clear"]).optional()
+  }),
+  toggles: base.extend({
+    defaultValue: z.array(id).max(12).optional(),
+    items: z.array(z.object({ id, label: shortText })).min(1).max(12),
+    kind: z.literal("toggle-group"),
+    selectionMode: z.enum(["multiple", "single"]).optional()
+  }),
+  viewEvent: base.extend({
+    date: z.string().trim().min(1).max(80),
+    kind: z.literal("view-event"),
+    time: z.string().trim().min(1).max(80),
+    tone: recordTone.optional()
+  }),
+  weatherCurrent: base.extend({
+    condition: weatherConditionSchema,
+    details: z.array(z.object({ label: shortText, value: shortText })).max(6).optional(),
+    kind: z.literal("weather-current"),
+    location: shortText,
+    temperature: z.number().finite().min(-150).max(150),
+    unit: weatherUnit
+  }),
+  weatherForecast: base.extend({
+    condition: weatherConditionSchema,
+    forecast: z.array(
+      z.object({
+        condition: weatherConditionSchema,
+        label: z.string().trim().min(1).max(40),
+        temperature: z.number().finite().min(-150).max(150)
+      })
+    ).min(2).max(10),
+    high: z.number().finite().min(-150).max(150),
+    kind: z.literal("weather-forecast"),
+    location: shortText,
+    low: z.number().finite().min(-150).max(150),
+    unit: weatherUnit
+  })
+};
+var metricGridComponentSchema = validators.metricGrid;
+var kpiGridComponentSchema = validators.kpiGrid;
+var lineChartComponentSchema = validators.line;
+var areaChartComponentSchema = validators.area;
+var barChartComponentSchema = validators.bar;
+var composedChartComponentSchema = validators.composed;
+var pieChartComponentSchema = validators.pie;
+var donutChartComponentSchema = validators.donut;
+var radarChartComponentSchema = validators.radar;
+var radialChartComponentSchema = validators.radial;
+var sankeyChartComponentSchema = validators.sankey;
+var scatterChartComponentSchema = validators.scatter;
+var heatmapComponentSchema = validators.heatmap;
+var dataTableComponentSchema = validators.table;
+var comparisonListComponentSchema = validators.comparison;
+var meterListComponentSchema = validators.meterList;
+var formComponentSchema = validators.form;
+var textComponentSchema = validators.text;
+var calloutComponentSchema = validators.callout;
+var imageComponentSchema = validators.image;
+var mapComponentSchema = validators.map;
+var tagListComponentSchema = validators.tags;
+var listComponentSchema = validators.list;
+var listBlockComponentSchema = validators.listBlock;
+var accordionComponentSchema = validators.accordion;
+var stepsComponentSchema = validators.steps;
+var codeBlockComponentSchema = validators.code;
+var diagramComponentSchema = validators.diagram;
+var tabsComponentSchema = validators.tabs.superRefine(validateTabsComponent);
+var actionGroupComponentSchema = validators.actions;
+var followupComponentSchema = validators.followup;
+var switchGroupComponentSchema = validators.switches;
+var toggleGroupComponentSchema = validators.toggles;
+var recordCardComponentSchema = validators.recordCard;
+var productCardComponentSchema = validators.productCard;
+var flightTrackerComponentSchema = validators.flightTracker;
+var createEventComponentSchema = validators.createEvent;
+var playlistComponentSchema = validators.playlist;
+var rideStatusComponentSchema = validators.rideStatus;
+var purchaseItemsComponentSchema = validators.purchaseItems;
+var channelMessageComponentSchema = validators.channelMessage;
+var purchaseCompleteComponentSchema = validators.purchaseComplete;
+var playerCardComponentSchema = validators.playerCard;
+var viewEventComponentSchema = validators.viewEvent;
+var eventSessionComponentSchema = validators.eventSession;
+var enableNotificationComponentSchema = validators.enableNotification;
+var weatherForecastComponentSchema = validators.weatherForecast;
+var weatherCurrentComponentSchema = validators.weatherCurrent;
+var analyticalLeafComponentSchema = z.discriminatedUnion("kind", [
+  validators.metricGrid,
+  validators.kpiGrid,
+  validators.line,
+  validators.area,
+  validators.bar,
+  validators.composed,
+  validators.pie,
+  validators.donut,
+  validators.radar,
+  validators.radial,
+  validators.sankey,
+  validators.scatter,
+  validators.heatmap,
+  validators.table,
+  validators.comparison,
+  validators.meterList
+]);
+var productSignalsShape = base.extend({
+  defaultValue: id.optional(),
+  kind: z.literal("product-signals"),
+  tabs: z.array(z.object({ component: analyticalLeafComponentSchema, id, label: shortText })).min(2).max(4)
+});
+var productSignalsComponentSchema = productSignalsShape.superRefine((signals, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, tab] of signals.tabs.entries()) {
+    if (ids.has(tab.id)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate product signal tab id "${tab.id}"`,
+        path: ["tabs", index, "id"]
+      });
+    }
+    ids.add(tab.id);
+  }
+  if (signals.defaultValue && !ids.has(signals.defaultValue)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "The default product signal must reference one of the tabs",
+      path: ["defaultValue"]
+    });
+  }
+});
+var standardAgentUILeafComponentSchema = z.discriminatedUnion("kind", [
+  validators.metricGrid,
+  validators.kpiGrid,
+  validators.line,
+  validators.area,
+  validators.bar,
+  validators.composed,
+  validators.pie,
+  validators.donut,
+  validators.radar,
+  validators.radial,
+  validators.sankey,
+  validators.scatter,
+  validators.heatmap,
+  validators.table,
+  validators.comparison,
+  validators.meterList,
+  validators.form,
+  validators.text,
+  validators.callout,
+  validators.image,
+  validators.map,
+  validators.tags,
+  validators.list,
+  validators.listBlock,
+  validators.accordion,
+  validators.steps,
+  validators.code,
+  validators.diagram,
+  validators.tabs,
+  validators.actions,
+  validators.followup,
+  validators.switches,
+  validators.toggles,
+  validators.recordCard,
+  validators.productCard,
+  validators.flightTracker,
+  validators.createEvent,
+  validators.playlist,
+  validators.rideStatus,
+  validators.purchaseItems,
+  validators.channelMessage,
+  validators.purchaseComplete,
+  validators.playerCard,
+  validators.viewEvent,
+  validators.eventSession,
+  validators.enableNotification,
+  validators.weatherForecast,
+  validators.weatherCurrent
+]);
+function findDuplicateId(items) {
+  if (!items) return void 0;
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (ids.has(item.id)) return item.id;
+    ids.add(item.id);
+  }
+  return void 0;
+}
+var agentUILeafComponentSchema = z.union([standardAgentUILeafComponentSchema, productSignalsComponentSchema]).superRefine((component, ctx) => {
+  const collections = [];
+  switch (component.kind) {
+    case "channel-message":
+      collections.push({ items: component.attachments, path: "attachments" });
+      break;
+    case "create-event":
+      collections.push({ items: component.events, path: "events" });
+      collections.push({ items: component.actions, path: "actions" });
+      break;
+    case "enable-notification":
+      collections.push({ items: component.actions, path: "actions" });
+      break;
+    case "playlist":
+      collections.push({ items: component.tracks, path: "tracks" });
+      collections.push({ items: component.actions, path: "actions" });
+      break;
+    case "purchase-items":
+      collections.push({ items: component.items, path: "items" });
+      collections.push({ items: component.actions, path: "actions" });
+      break;
+    case "tabs": {
+      validateTabsComponent(component, ctx);
+      break;
+    }
+    default:
+      break;
+  }
+  for (const collection of collections) {
+    const duplicateId = findDuplicateId(collection.items);
+    if (duplicateId) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate ${collection.path} id "${duplicateId}"`,
+        path: [collection.path]
+      });
+    }
+  }
+});
+var dashboardShape = base.extend({
+  children: z.array(agentUILeafComponentSchema).min(1).max(4),
+  kind: z.literal("dashboard"),
+  layout: z.enum(["chart-table", "grid", "metrics-chart", "stack"])
+});
+var dashboardComponentSchema = dashboardShape;
+var agentUIComponentSchema = z.union([
+  agentUILeafComponentSchema,
+  dashboardComponentSchema
+]);
+var renderComponentInputSchema = z.object({
+  component: agentUIComponentSchema
+});
+var COMPOSED_UI_MAX_DEPTH = 6;
+var COMPOSED_UI_MAX_NODES = 48;
+var CONTAINER_KINDS = /* @__PURE__ */ new Set([
+  "card",
+  "col",
+  "grid",
+  "item-card",
+  "item-card-group",
+  "row"
+]);
+var LAYOUT_LEAF_KINDS = /* @__PURE__ */ new Set(["divider", "spacer"]);
+var PRIMITIVE_KINDS = /* @__PURE__ */ new Set([
+  "badge",
+  "button",
+  "heading",
+  "icon",
+  "progress",
+  "rating"
+]);
+var AGENT_UI_CONTAINER_KINDS = CONTAINER_KINDS;
+var AGENT_UI_LAYOUT_LEAF_KINDS = LAYOUT_LEAF_KINDS;
+var AGENT_UI_PRIMITIVE_KINDS = PRIMITIVE_KINDS;
+function isAgentUIContainerComponent(node) {
+  return CONTAINER_KINDS.has(node.kind);
+}
+function getAgentUIContainerChildren(node) {
+  if (node.kind === "item-card") {
+    return [...node.left ?? [], ...node.middle, ...node.right ?? []];
+  }
+  return node.children;
+}
+function isAgentUILayoutLeafComponent(node) {
+  return LAYOUT_LEAF_KINDS.has(node.kind);
+}
+function isAgentUIPrimitiveComponent(node) {
+  return PRIMITIVE_KINDS.has(node.kind);
+}
+var layoutBase = z.object({ id });
+var layoutGap = z.enum(["lg", "md", "none", "sm"]);
+var layoutAlign = z.enum(["center", "end", "start", "stretch"]);
+var layoutJustify = z.enum(["between", "center", "end", "start"]);
+var nodeChildren = z.array(z.lazy(() => agentUINodeSchema)).min(1).max(COMPOSED_UI_MAX_NODES);
+var spacerComponentSchema = layoutBase.extend({
+  kind: z.literal("spacer"),
+  size: z.enum(["auto", "lg", "md", "sm"]).optional()
+});
+var dividerComponentSchema = layoutBase.extend({
+  kind: z.literal("divider")
+});
+var headingComponentSchema = layoutBase.extend({
+  icon: agentIconSchema.optional(),
+  kind: z.literal("heading"),
+  level: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).optional(),
+  text: shortText
+});
+var buttonComponentSchema = layoutBase.extend({
+  icon: agentIconSchema.optional(),
+  kind: z.literal("button"),
+  label: shortText,
+  prompt: z.string().trim().min(1).max(2e3).optional(),
+  toolCall: actionToolCall.optional(),
+  variant: actionVariant.optional()
+}).refine((button) => Boolean(button.prompt ?? button.toolCall), {
+  message: "Buttons need a prompt or a toolCall to do something when pressed"
+});
+var badgeComponentSchema = layoutBase.extend({
+  kind: z.literal("badge"),
+  label: shortText,
+  tone: recordTone.optional(),
+  variant: z.enum(["soft", "solid"]).optional()
+});
+var iconComponentSchema = layoutBase.extend({
+  kind: z.literal("icon"),
+  name: agentIconSchema,
+  size: z.enum(["lg", "md", "sm"]).optional(),
+  tone: recordTone.optional()
+});
+var ratingComponentSchema = layoutBase.extend({
+  count: z.number().int().nonnegative().max(1e9).optional(),
+  kind: z.literal("rating"),
+  value: z.number().finite().min(0).max(5)
+});
+var progressComponentSchema = layoutBase.extend({
+  kind: z.literal("progress"),
+  label: shortText.optional(),
+  value: z.number().finite().min(0).max(100)
+});
+var itemCardVariant = z.enum(["default", "outline", "secondary", "tertiary", "transparent"]);
+var itemCardSlotNode = z.lazy(() => agentUINodeSchema);
+var itemCardShape = base.extend({
+  action: action.optional().describe(
+    "Makes the whole row pressable. Omit when a slot contains its own button or other interactive control."
+  ),
+  isDisabled: z.boolean().optional(),
+  isSelected: z.boolean().optional(),
+  kind: z.literal("item-card"),
+  left: z.array(itemCardSlotNode).min(1).max(4).optional().describe("Leading slot. Prefer one icon node or a compact visual."),
+  middle: z.array(itemCardSlotNode).min(1).max(8).describe(
+    "Primary flexible slot. Prefer a level-4 heading followed by a clear text node for a title and description."
+  ),
+  right: z.array(itemCardSlotNode).min(1).max(4).optional().describe("Trailing slot. Prefer a badge, short value, icon, or button."),
+  variant: itemCardVariant.optional()
+});
+var INTERACTIVE_ITEM_CARD_DESCENDANT_KINDS = /* @__PURE__ */ new Set([
+  "accordion",
+  "action-group",
+  "button",
+  "followup",
+  "form",
+  "map",
+  "switch-group",
+  "tabs",
+  "toggle-group"
+]);
+function containsInteractiveItemCardDescendant(nodes) {
+  for (const node of nodes) {
+    if (INTERACTIVE_ITEM_CARD_DESCENDANT_KINDS.has(node.kind)) return true;
+    if (isAgentUIContainerComponent(node) && containsInteractiveItemCardDescendant(getAgentUIContainerChildren(node))) {
+      return true;
+    }
+  }
+  return false;
+}
+var itemCardComponentSchema = itemCardShape.superRefine(
+  (card, ctx) => {
+    if (card.action && containsInteractiveItemCardDescendant([
+      ...card.left ?? [],
+      ...card.middle,
+      ...card.right ?? []
+    ])) {
+      ctx.addIssue({
+        code: "custom",
+        message: "A pressable item-card cannot contain buttons or other interactive descendants. Remove action from the card or move the nested control outside it."
+      });
+    }
+  }
+);
+var itemCardGroupShape = base.extend({
+  children: z.array(itemCardComponentSchema).min(1).max(12),
+  columns: z.union([z.literal(2), z.literal(3)]).optional(),
+  kind: z.literal("item-card-group"),
+  layout: z.enum(["grid", "list"]).optional(),
+  showHeader: z.boolean().optional(),
+  variant: itemCardVariant.optional()
+});
+var itemCardGroupComponentSchema = itemCardGroupShape.superRefine((group2, ctx) => {
+  if (group2.columns && group2.layout !== "grid") {
+    ctx.addIssue({
+      code: "custom",
+      message: "Item-card group columns only apply when layout is grid.",
+      path: ["columns"]
+    });
+  }
+});
+var rowShape = layoutBase.extend({
+  align: layoutAlign.optional(),
+  children: nodeChildren,
+  gap: layoutGap.optional(),
+  justify: layoutJustify.optional(),
+  kind: z.literal("row")
+});
+var colShape = layoutBase.extend({
+  align: layoutAlign.optional(),
+  children: nodeChildren,
+  gap: layoutGap.optional(),
+  justify: layoutJustify.optional(),
+  kind: z.literal("col")
+});
+var gridShape = layoutBase.extend({
+  children: nodeChildren,
+  columns: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]),
+  gap: layoutGap.optional(),
+  kind: z.literal("grid")
+});
+var cardShape = base.extend({
+  children: nodeChildren,
+  kind: z.literal("card"),
+  variant: cardComponentVariantSchema.optional()
+});
+var rowComponentSchema = rowShape;
+var colComponentSchema = colShape;
+var gridComponentSchema = gridShape;
+var cardComponentSchema = cardShape;
+var agentUINodeSchema = z.union([
+  agentUILeafComponentSchema,
+  spacerComponentSchema,
+  dividerComponentSchema,
+  headingComponentSchema,
+  buttonComponentSchema,
+  badgeComponentSchema,
+  iconComponentSchema,
+  ratingComponentSchema,
+  progressComponentSchema,
+  rowComponentSchema,
+  colComponentSchema,
+  gridComponentSchema,
+  cardComponentSchema,
+  itemCardComponentSchema,
+  itemCardGroupComponentSchema
+]);
+function validateComposedTree(root, ctx) {
+  validateNodeTree(root, ctx);
+}
+function validateTabContentTrees(component, ctx) {
+  const richChildren = component.tabs.flatMap((tab) => tab.children ?? []);
+  if (richChildren.length === 0) return;
+  validateNodeForest(richChildren, ctx, component.id, 2, 1);
+}
+function validateTabsComponent(component, ctx) {
+  const tabIds = /* @__PURE__ */ new Set();
+  for (const [index, tab] of component.tabs.entries()) {
+    if (tabIds.has(tab.id)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate tab id "${tab.id}"`,
+        path: ["tabs", index, "id"]
+      });
+    }
+    tabIds.add(tab.id);
+  }
+  if (component.defaultValue && !tabIds.has(component.defaultValue)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "The default tab must reference one of the tabs",
+      path: ["defaultValue"]
+    });
+  }
+  validateTabContentTrees(component, ctx);
+}
+function nestedNodeChildren(node) {
+  if (isAgentUIContainerComponent(node)) return getAgentUIContainerChildren(node);
+  if (node.kind === "tabs") return node.tabs.flatMap((tab) => tab.children ?? []);
+  return [];
+}
+function validateNodeForest(roots, ctx, reservedRootId, initialDepth = 1, initialNodeCount = 0) {
+  const ids = /* @__PURE__ */ new Set();
+  let nodeCount = initialNodeCount;
+  let deepest = initialNodeCount > 0 ? initialDepth - 1 : 0;
+  if (reservedRootId) ids.add(reservedRootId);
+  const walk = (node, depth) => {
+    nodeCount += 1;
+    deepest = Math.max(deepest, depth);
+    if (ids.has(node.id)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate component id "${node.id}" in the composed UI tree. Every node needs a unique id.`
+      });
+    }
+    ids.add(node.id);
+    if (depth > COMPOSED_UI_MAX_DEPTH) return;
+    for (const child of nestedNodeChildren(node)) walk(child, depth + 1);
+  };
+  for (const root of roots) walk(root, initialDepth);
+  if (deepest > COMPOSED_UI_MAX_DEPTH) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Composed UI trees can nest at most ${COMPOSED_UI_MAX_DEPTH} levels deep.`
+    });
+  }
+  if (nodeCount > COMPOSED_UI_MAX_NODES) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Composed UI trees can contain at most ${COMPOSED_UI_MAX_NODES} components.`
+    });
+  }
+}
+function validateNodeTree(root, ctx) {
+  validateNodeForest([root], ctx);
+}
+var composedUIComponentSchema = z.union([
+  rowComponentSchema,
+  colComponentSchema,
+  gridComponentSchema,
+  cardComponentSchema,
+  itemCardComponentSchema,
+  itemCardGroupComponentSchema
+]).superRefine(validateComposedTree);
+var agentUIRenderableSchema = z.union([
+  agentUIComponentSchema,
+  composedUIComponentSchema
+]);
+var composeUIInputSchema = z.object({
+  component: composedUIComponentSchema
+});
+var opaqueChildren = (max) => z.array(z.unknown()).min(1).max(max).describe("Child nodes. Each is any catalog component; look its kind up separately.");
+var AGENT_UI_KIND_SCHEMAS = {
+  accordion: accordionComponentSchema,
+  "action-group": actionGroupComponentSchema,
+  "area-chart": areaChartComponentSchema,
+  badge: badgeComponentSchema,
+  "bar-chart": barChartComponentSchema,
+  button: buttonComponentSchema,
+  callout: calloutComponentSchema,
+  card: cardShape.extend({ children: opaqueChildren(COMPOSED_UI_MAX_NODES) }),
+  "channel-message": channelMessageComponentSchema,
+  "code-block": codeBlockComponentSchema,
+  col: colShape.extend({ children: opaqueChildren(COMPOSED_UI_MAX_NODES) }),
+  "comparison-list": comparisonListComponentSchema,
+  "composed-chart": composedChartComponentSchema,
+  "create-event": createEventComponentSchema,
+  dashboard: dashboardShape.extend({ children: opaqueChildren(4) }),
+  "data-table": dataTableComponentSchema,
+  diagram: diagramComponentSchema,
+  divider: dividerComponentSchema,
+  "donut-chart": donutChartComponentSchema,
+  "enable-notification": enableNotificationComponentSchema,
+  "event-session": eventSessionComponentSchema,
+  "flight-tracker": flightTrackerComponentSchema,
+  followup: followupComponentSchema,
+  form: formComponentSchema,
+  grid: gridShape.extend({ children: opaqueChildren(COMPOSED_UI_MAX_NODES) }),
+  heading: headingComponentSchema,
+  heatmap: heatmapComponentSchema,
+  icon: iconComponentSchema,
+  image: imageComponentSchema,
+  "item-card": itemCardShape.extend({
+    left: opaqueChildren(4).optional().describe("Leading slot nodes."),
+    middle: opaqueChildren(8).describe("Primary flexible slot nodes."),
+    right: opaqueChildren(4).optional().describe("Trailing slot nodes.")
+  }),
+  "item-card-group": itemCardGroupShape.extend({
+    children: z.array(z.unknown()).min(1).max(12).describe("One to twelve item-card children. Look up item-card for each child's schema.")
+  }),
+  "kpi-grid": kpiGridComponentSchema,
+  "line-chart": lineChartComponentSchema,
+  list: listComponentSchema,
+  "list-block": listBlockComponentSchema,
+  map: mapComponentSchema,
+  "meter-list": meterListComponentSchema,
+  "metric-grid": metricGridComponentSchema,
+  "pie-chart": pieChartComponentSchema,
+  "player-card": playerCardComponentSchema,
+  playlist: playlistComponentSchema,
+  "product-card": productCardComponentSchema,
+  "product-signals": productSignalsShape.extend({
+    tabs: z.array(
+      z.object({
+        component: z.unknown().describe(
+          "One analytical component: metric-grid, kpi-grid, any chart, data-table, comparison-list, or meter-list. Look its kind up separately."
+        ),
+        id,
+        label: shortText
+      })
+    ).min(2).max(4)
+  }),
+  progress: progressComponentSchema,
+  "purchase-complete": purchaseCompleteComponentSchema,
+  "purchase-items": purchaseItemsComponentSchema,
+  "radar-chart": radarChartComponentSchema,
+  "radial-chart": radialChartComponentSchema,
+  rating: ratingComponentSchema,
+  "record-card": recordCardComponentSchema,
+  "ride-status": rideStatusComponentSchema,
+  row: rowShape.extend({ children: opaqueChildren(COMPOSED_UI_MAX_NODES) }),
+  "sankey-chart": sankeyChartComponentSchema,
+  "scatter-chart": scatterChartComponentSchema,
+  spacer: spacerComponentSchema,
+  steps: stepsComponentSchema,
+  "switch-group": switchGroupComponentSchema,
+  tabs: base.extend({
+    defaultValue: id.optional(),
+    kind: z.literal("tabs"),
+    tabs: z.array(
+      z.union([
+        z.object({
+          content,
+          id,
+          label: shortText
+        }),
+        z.object({
+          children: opaqueChildren(12).describe(
+            "Rich panel nodes rendered as one vertical stack. Look up every child kind separately."
+          ),
+          id,
+          label: shortText
+        })
+      ])
+    ).min(1).max(10),
+    variant: z.enum(["primary", "secondary"]).optional()
+  }),
+  "tag-list": tagListComponentSchema,
+  text: textComponentSchema,
+  "toggle-group": toggleGroupComponentSchema,
+  "view-event": viewEventComponentSchema,
+  "weather-current": weatherCurrentComponentSchema,
+  "weather-forecast": weatherForecastComponentSchema
+};
+
+// ../agent-ui/src/contracts/catalog.ts
+var SUMMARIES = {
+  accordion: "collapsible sections of longer prose",
+  "action-group": "buttons that send prompts or call client tools",
+  "area-chart": "one continuous time series with a filled trend",
+  badge: "a small toned status label",
+  "bar-chart": "ranked or categorical comparison, horizontal layout for rankings",
+  button: "one action with a prompt or client-tool call",
+  callout: "one short toned notice: info, success, warning, or danger",
+  card: "titled surface grouping related children",
+  "channel-message": "a quoted workspace message with author and attachments",
+  "code-block": "a syntax-highlighted snippet",
+  col: "stacks children vertically",
+  "comparison-list": "labeled values with change deltas, no axes",
+  "composed-chart": "two to five mixed area/bar/line series, optional dual axis",
+  "create-event": "a proposed calendar slot beside surrounding events",
+  dashboard: "up to four analytical children in a fixed layout",
+  "data-table": "exact values in filterable rows and columns",
+  diagram: "a flowchart, sequence, ER, or state diagram from Mermaid source, for processes and relationships prose cannot show",
+  divider: "a rule between sections",
+  "donut-chart": "proportions of a whole with a hollow center",
+  "enable-notification": "a binary notification opt-in with two actions",
+  "event-session": "a conference session with time, location, and speakers",
+  "flight-tracker": "a flight's route, times, and live progress",
+  followup: "suggested next prompts the user can send",
+  form: "input fields with submit actions",
+  grid: "one to four equal columns of peers",
+  heading: "a section title, levels one to four",
+  heatmap: "two-dimensional intensity across x and y",
+  icon: "one semantic glyph from the icon vocabulary",
+  image: "one to six real image URLs with captions in a grid or horizontal chat gallery",
+  "item-card": "one compact three-slot row with composable left, middle, and right content",
+  "item-card-group": "one to twelve related item-card rows in a list or grid",
+  "kpi-grid": "up to four headline KPIs, each with a sparkline of its own history",
+  "line-chart": "two or more overlapping series needing equal weight",
+  list: "bulleted, numbered, or checklist items with optional children",
+  "list-block": "richer rows with title, description, meta, rating, icon, or image",
+  map: "ranked places pinned by exact latitude and longitude",
+  "meter-list": "bounded quantities such as quota, utilization, or budget",
+  "metric-grid": "up to four headline KPIs with no history to plot",
+  "pie-chart": "proportions of a whole",
+  "player-card": "an athlete with jersey, portrait, and stat lines",
+  playlist: "a track collection with cover and per-track actions",
+  "product-card": "purchasable items with image, price, rating, availability",
+  "product-signals": "two to four related analytical views in tabs",
+  progress: "a zero to one hundred percentage bar",
+  "purchase-complete": "confirmation after a successful transaction",
+  "purchase-items": "a cart or order summary with line items and totals",
+  "radar-chart": "multivariate comparison across three or more axes",
+  "radial-chart": "compact circular measure",
+  rating: "a zero to five star score with optional count",
+  "record-card": "one entity's labeled facts, layouts details/compact/media",
+  "ride-status": "pickup ETA and driver for a ride in progress",
+  row: "places complementary children side by side",
+  "sankey-chart": "flow volumes between source and target nodes",
+  "scatter-chart": "correlation between two numeric fields, optional grouping",
+  spacer: "a gap between siblings",
+  steps: "task progress or a chronological timeline, up to twelve entries",
+  "switch-group": "toggleable boolean preferences",
+  tabs: "parallel text or rich multi-component sections behind labeled tabs",
+  "tag-list": "short keyword chips",
+  text: "explanatory markdown prose",
+  "toggle-group": "single or multiple choice from short options",
+  "view-event": "one calendar event's date, time, and tone",
+  "weather-current": "current conditions in one location",
+  "weather-forecast": "multi-day or future conditions with highs and lows"
+};
+var GROUP_BY_CATEGORY = {
+  actions: "actions",
+  "data-visualization": "data",
+  "display-information": "display",
+  "form-elements": "forms"
+};
+function groupFor(kind) {
+  if (kind === "dashboard" || AGENT_UI_CONTAINER_KINDS.has(kind)) return "containers";
+  if (AGENT_UI_LAYOUT_LEAF_KINDS.has(kind)) return "layout";
+  if (AGENT_UI_PRIMITIVE_KINDS.has(kind)) return "primitives";
+  return GROUP_BY_CATEGORY[COMPONENT_CATEGORY_BY_KIND[kind]] ?? "display";
+}
+var AGENT_UI_CATALOG = Object.fromEntries(
+  Object.entries(SUMMARIES).map(([kind, summary]) => [
+    kind,
+    { group: groupFor(kind), summary }
+  ])
+);
+var AGENT_UI_KIND_NAMES = Object.keys(
+  SUMMARIES
+).sort();
+var GROUP_LABELS = [
+  ["containers", "Containers"],
+  ["layout", "Layout"],
+  ["primitives", "Primitives"],
+  ["data", "Data"],
+  ["display", "Content"],
+  ["actions", "Actions"],
+  ["forms", "Forms"]
+];
+function renderAgentUICatalogPrompt() {
+  const lines = GROUP_LABELS.map(([group2, label]) => {
+    const entries = AGENT_UI_KIND_NAMES.filter(
+      (kind) => AGENT_UI_CATALOG[kind].group === group2
+    ).map((kind) => `${kind} \u2014 ${AGENT_UI_CATALOG[kind].summary}`);
+    return `${label}: ${entries.join("; ")}.`;
+  });
+  return lines.join("\n");
+}
+
+// src/contracts/client-tools.ts
+import { z as z2 } from "zod";
+var RESERVED_AGENT_TOOL_NAMES = [
+  "composeUI",
+  "executeSandbox",
+  "getComponentSchema",
+  "loadUIRenderers",
+  "renderComponent",
+  "searchKnowledge",
+  "searchWeb"
+];
+var RESERVED_AGENT_TOOL_PREFIX = "mcp_";
+var MAX_CLIENT_TOOLS = 20;
+var MAX_CLIENT_TOOLS_BYTES = 16 * 1024;
+var clientToolManifestEntrySchema = z2.object({
+  description: z2.string().trim().min(1).max(1e3),
+  inputSchema: z2.record(z2.string(), z2.unknown()),
+  name: z2.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/).refine(
+    (name) => !RESERVED_AGENT_TOOL_NAMES.includes(name) && !name.toLowerCase().startsWith(RESERVED_AGENT_TOOL_PREFIX),
+    "Client tool name is reserved by the HeroUI Agent runtime"
+  ),
+  needsApproval: z2.boolean().optional()
+});
+var clientToolsSchema = z2.array(clientToolManifestEntrySchema).max(MAX_CLIENT_TOOLS).superRefine((tools, context) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of tools) {
+    if (names.has(entry.name)) {
+      context.addIssue({ code: "custom", message: `Duplicate client tool name: ${entry.name}` });
+    }
+    names.add(entry.name);
+  }
+  if (new TextEncoder().encode(JSON.stringify(tools)).byteLength > MAX_CLIENT_TOOLS_BYTES) {
+    context.addIssue({ code: "custom", message: "Client tool manifest exceeds 16KB" });
+  }
+});
+
+// src/contracts/identity.ts
+import { z as z4 } from "zod";
+
+// src/contracts/models.schema.ts
+import { z as z3 } from "zod";
+
+// src/contracts/models.ts
+var AGENT_MODEL_IDS = [
+  "moonshotai/Kimi-K3",
+  "openai/gpt-5.6-luna",
+  "openai/gpt-5.6-terra",
+  "openai/gpt-5.6-sol",
+  "google/gemini-3.6-flash",
+  "anthropic/claude-sonnet-5",
+  "anthropic/claude-opus-4.8"
+];
+var LEGACY_AGENT_MODEL_IDS = {
+  "google/gemini-3.5-flash": "google/gemini-3.6-flash"
+};
+function resolveAgentModelId(value) {
+  return LEGACY_AGENT_MODEL_IDS[value] ?? value;
+}
+var DEFAULT_AGENT_PICKER_MODEL_ID = "openai/gpt-5.6-luna";
+var AGENT_MODEL_OPTIONS = [
+  {
+    description: "Flagship model for coding, reasoning, and knowledge work",
+    id: "moonshotai/Kimi-K3",
+    label: "Kimi K3",
+    provider: "Moonshot AI",
+    tier: "light"
+  },
+  {
+    description: "Fast answers and lightweight agent workflows",
+    id: "openai/gpt-5.6-luna",
+    label: "GPT-5.6 Luna",
+    provider: "OpenAI",
+    tier: "light"
+  },
+  {
+    description: "Balanced reasoning for everyday agent tasks",
+    id: "openai/gpt-5.6-terra",
+    label: "GPT-5.6 Terra",
+    provider: "OpenAI",
+    tier: "codegen"
+  },
+  {
+    description: "Deep reasoning for complex, multi-step analysis",
+    id: "openai/gpt-5.6-sol",
+    label: "GPT-5.6 Sol",
+    provider: "OpenAI",
+    tier: "complex"
+  },
+  {
+    description: "Fast multimodal analysis with a large context window",
+    id: "google/gemini-3.6-flash",
+    label: "Gemini 3.6 Flash",
+    provider: "Google",
+    tier: "light"
+  },
+  {
+    description: "Strong agentic reasoning and polished UI decisions",
+    id: "anthropic/claude-sonnet-5",
+    label: "Claude Sonnet 5",
+    provider: "Anthropic",
+    tier: "codegen"
+  },
+  {
+    description: "Highest-capability Claude for difficult research and analysis",
+    id: "anthropic/claude-opus-4.8",
+    label: "Claude Opus 4.8",
+    provider: "Anthropic",
+    tier: "complex"
+  }
+];
+var AGENT_MODEL_ID_SET = new Set(AGENT_MODEL_IDS);
+function isAgentModelId(value) {
+  return typeof value === "string" && AGENT_MODEL_ID_SET.has(value);
+}
+function getAgentModelTier(modelId) {
+  const resolved = modelId ? resolveAgentModelId(modelId) : void 0;
+  return AGENT_MODEL_OPTIONS.find((option2) => option2.id === resolved)?.tier ?? "light";
+}
+
+// src/contracts/models.schema.ts
+var agentModelIdSchema = z3.preprocess(
+  (value) => typeof value === "string" ? resolveAgentModelId(value) : value,
+  z3.enum(AGENT_MODEL_IDS)
+);
+
+// src/contracts/version.ts
+var HEROUI_AGENT_PROTOCOL_VERSION = 5;
+var HEROUI_AGENT_SDK_VERSION = "0.2.0-beta.1";
+var HEROUI_AGENT_TASK_ID = "heroui-agents-runtime";
+var TRUSTED_AGENT_CLIENT_DATA_KEY = "__heroUiAgentApi";
+
+// src/contracts/identity.ts
+var agentThemeSchema = z4.enum(["light", "dark", "system"]);
+var agentSurfaceVariantSchema = z4.enum([
+  "outline",
+  "plain",
+  "surface",
+  "surface-secondary"
+]);
+var pageContextSchema = z4.record(z4.string().max(100), z4.unknown());
+var RESERVED_IDENTITY_IDS = /* @__PURE__ */ new Set([
+  "[object object]",
+  "0",
+  "anonymous",
+  "distinct_id",
+  "distinctid",
+  "email",
+  "false",
+  "guest",
+  "id",
+  "nan",
+  "none",
+  "not_authenticated",
+  "null",
+  "true",
+  "undefined"
+]);
+var agentIdentityIdSchema = z4.string().trim().min(1).max(200).refine((value) => !RESERVED_IDENTITY_IDS.has(value.toLowerCase()), {
+  message: "Identity id is reserved"
+});
+var agentAuthIdentitySchema = z4.discriminatedUnion("type", [
+  z4.object({
+    id: agentIdentityIdSchema,
+    type: z4.literal("anonymous")
+  }),
+  z4.object({
+    id: agentIdentityIdSchema,
+    type: z4.literal("user")
+  })
+]);
+var agentAuthProfileSchema = z4.object({
+  avatarUrl: z4.string().trim().pipe(z4.url()).optional(),
+  email: z4.string().trim().max(320).pipe(z4.email()).optional(),
+  name: z4.string().trim().max(120).optional()
+});
+var createAgentAuthTokenRequestSchema = z4.object({
+  /**
+   * Browser-scoped id the SDK passed to the host callback. Sending it together
+   * with an identified `identity` merges that anonymous person's conversations
+   * into the identified user, so history survives login.
+   */
+  anonymousId: agentIdentityIdSchema.optional(),
+  identity: agentAuthIdentitySchema,
+  profile: agentAuthProfileSchema.optional()
+});
+var agentAuthTokenSchema = z4.object({
+  expiresAt: z4.number().int().positive(),
+  token: z4.string().trim().min(1)
+});
+var agentTokenClaimsSchema = z4.object({
+  agentId: z4.string().trim().min(1).max(100),
+  apiKeyId: z4.string().trim().min(1).max(100),
+  aud: z4.literal("heroui-agent"),
+  exp: z4.number().int().positive(),
+  iat: z4.number().int().positive(),
+  iss: z4.literal("https://api.heroui.com"),
+  jti: z4.uuid(),
+  protocolVersion: z4.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  sub: z4.string().trim().min(1).max(200)
+});
+var trustedAgentClientDataSchema = z4.object({
+  agentId: z4.string(),
+  billingLicenseId: z4.string().nullable(),
+  billingOwnerUserId: z4.string(),
+  /**
+   * Browser-declared client tools the embed can execute for this turn. The
+   * runtime registers them as model-visible tools without an execute function.
+   */
+  clientTools: clientToolsSchema.default([]),
+  conversationId: z4.uuid(),
+  /**
+   * Pseudonymous identity used by persisted conversations. This is signed by
+   * the API so the runtime can link telemetry without handling a raw identity.
+   */
+  endUserKey: z4.string().trim().min(1).max(200).optional(),
+  /**
+   * When web search is enabled, allow image results via `includeImages`.
+   * Defaults to true at the host when omitted; optional here so signed
+   * payloads without the field stay valid and keep image search on.
+   */
+  imageSearch: z4.boolean().optional(),
+  /**
+   * Optional browser-selected OpenRouter model. The API accepts only the
+   * fixed agent allowlist and signs the value before the runtime sees it.
+   */
+  modelId: agentModelIdSchema.optional(),
+  pageContext: pageContextSchema.default({}),
+  /**
+   * Set by the API when the session was authorized by a dashboard preview
+   * credential rather than a host API key, so operator traffic can be separated
+   * from real visitors. Optional (not defaulted) to keep older signed payloads
+   * valid.
+   */
+  preview: z4.boolean().optional(),
+  protocolVersion: z4.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  requestId: z4.uuid(),
+  sdkVersion: z4.string().trim().min(1).max(80),
+  signedAt: z4.number(),
+  subject: z4.string(),
+  /**
+   * Host-enabled public web search. When true the runtime registers the
+   * `searchWeb` tool (if the search backend is configured) so the agent can
+   * look up public information and images. Optional (not defaulted) so schema
+   * parsing never injects a field into an already-signed payload.
+   */
+  webSearch: z4.boolean().optional()
+});
+var signedTrustedAgentClientDataSchema = trustedAgentClientDataSchema.extend({
+  sig: z4.string().min(1)
+});
+var AGENT_CONVERSATION_SOURCE = {
+  embed: "embed",
+  preview: "preview"
+};
+var agentProjectConfigSchema = z4.object({
+  agentId: z4.string(),
+  minimumProtocolVersion: z4.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  name: z4.string().trim().min(1).max(120),
+  protocolVersion: z4.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  /**
+   * Internal streaming infrastructure endpoint, resolved server-side so
+   * customers never configure it. Optional for compatibility with older API
+   * deployments; the SDK falls back to Trigger.dev's public endpoint.
+   */
+  realtime: z4.object({ url: z4.url() }).optional(),
+  sdkVersion: z4.string().default(HEROUI_AGENT_SDK_VERSION),
+  suggestedPrompts: z4.array(z4.string().trim().min(1).max(160)).max(5),
+  surfaceVariant: agentSurfaceVariantSchema.default("plain"),
+  theme: agentThemeSchema
+});
+
+// src/contracts/messages.ts
+import { z as z5 } from "zod";
+var agentSourceBaseSchema = z5.object({
+  excerpt: z5.string().trim().min(1).max(2e3).optional(),
+  locator: z5.string().trim().min(1).max(160).optional(),
+  sourceId: z5.string().trim().min(1).max(120)
+});
+var safeSourceUrlSchema = z5.string().trim().max(2048).refine((value) => {
+  try {
+    return ["http:", "https:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+});
+var agentSourceSchema = z5.union([
+  agentSourceBaseSchema.extend({
+    sourceType: z5.literal("document"),
+    title: z5.string().trim().min(1).max(200)
+  }),
+  agentSourceBaseSchema.extend({
+    sourceType: z5.literal("url").optional(),
+    title: z5.string().trim().min(1).max(200).optional(),
+    url: safeSourceUrlSchema
+  })
+]);
+var agentSourcesSchema = z5.object({
+  items: z5.array(agentSourceSchema).min(1).max(16)
+});
+
+// src/contracts/trusted.ts
+function canonicalize(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key2, entryValue]) => `${JSON.stringify(key2)}:${canonicalize(entryValue)}`);
+  return `{${entries.join(",")}}`;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    mismatch |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  }
+  return mismatch === 0;
+}
+async function hmacHex(secret, input) {
+  const key2 = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { hash: "SHA-256", name: "HMAC" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key2, new TextEncoder().encode(input));
+  return Array.from(new Uint8Array(signature), (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+async function signTrustedAgentClientData(secret, data) {
+  return { ...data, sig: await hmacHex(secret, canonicalize(data)) };
+}
+async function verifyTrustedAgentClientData(secret, value) {
+  if (!value || typeof value !== "object") return null;
+  const { sig, ...data } = value;
+  if (typeof sig !== "string" || !sig) return null;
+  const expected = await hmacHex(secret, canonicalize(data));
+  return timingSafeEqual(sig, expected) ? data : null;
+}
+export {
+  AGENT_CONVERSATION_SOURCE,
+  AGENT_MODEL_IDS,
+  AGENT_MODEL_OPTIONS,
+  AGENT_UI_CATALOG,
+  AGENT_UI_CONTAINER_KINDS,
+  AGENT_UI_KIND_NAMES,
+  AGENT_UI_KIND_SCHEMAS,
+  AGENT_UI_LAYOUT_LEAF_KINDS,
+  AGENT_UI_PRIMITIVE_KINDS,
+  COMPOSED_UI_MAX_DEPTH,
+  COMPOSED_UI_MAX_NODES,
+  DEFAULT_AGENT_PICKER_MODEL_ID,
+  HEROUI_AGENT_ATTACHMENT_ACCEPT,
+  HEROUI_AGENT_ATTACHMENT_CONTENT_TYPES,
+  HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE,
+  HEROUI_AGENT_ATTACHMENT_MAX_BYTES,
+  HEROUI_AGENT_MAX_ATTACHMENTS,
+  HEROUI_AGENT_PROTOCOL_VERSION,
+  HEROUI_AGENT_REMOTE_CONFIG_VERSION,
+  HEROUI_AGENT_SDK_VERSION,
+  HEROUI_AGENT_TASK_ID,
+  HEROUI_AGENT_TEXT_ATTACHMENT_CONTENT_TYPES,
+  LEGACY_AGENT_MODEL_IDS,
+  MAX_CLIENT_TOOLS,
+  MAX_CLIENT_TOOLS_BYTES,
+  RESERVED_AGENT_TOOL_NAMES,
+  RESERVED_AGENT_TOOL_PREFIX,
+  TRUSTED_AGENT_CLIENT_DATA_KEY,
+  accordionComponentSchema,
+  actionGroupComponentSchema,
+  agentAuthIdentitySchema,
+  agentAuthProfileSchema,
+  agentAuthTokenSchema,
+  agentIconNames,
+  agentIconSchema,
+  agentIdentityIdSchema,
+  agentModelIdSchema,
+  agentProjectConfigSchema,
+  agentSourceSchema,
+  agentSourcesSchema,
+  agentSurfaceVariantSchema,
+  agentThemeSchema,
+  agentTokenClaimsSchema,
+  agentUIComponentSchema,
+  agentUILeafComponentSchema,
+  agentUINodeSchema,
+  agentUIRenderableSchema,
+  analyticalLeafComponentSchema,
+  areaChartComponentSchema,
+  badgeComponentSchema,
+  barChartComponentSchema,
+  buttonComponentSchema,
+  calloutComponentSchema,
+  cardComponentSchema,
+  cardComponentVariantSchema,
+  channelMessageComponentSchema,
+  chartColorSchema,
+  clientToolManifestEntrySchema,
+  clientToolsSchema,
+  codeBlockComponentSchema,
+  colComponentSchema,
+  comparisonListComponentSchema,
+  composeUIInputSchema,
+  composedChartComponentSchema,
+  composedUIComponentSchema,
+  createAgentAuthTokenRequestSchema,
+  createEventComponentSchema,
+  dashboardComponentSchema,
+  dataTableComponentSchema,
+  diagramComponentSchema,
+  dividerComponentSchema,
+  donutChartComponentSchema,
+  enableNotificationComponentSchema,
+  eventSessionComponentSchema,
+  flightTrackerComponentSchema,
+  followupComponentSchema,
+  formComponentSchema,
+  getAgentModelTier,
+  getAgentUIContainerChildren,
+  gridComponentSchema,
+  headingComponentSchema,
+  heatmapComponentSchema,
+  iconComponentSchema,
+  imageComponentSchema,
+  isAgentModelId,
+  isAgentUIContainerComponent,
+  isAgentUILayoutLeafComponent,
+  isAgentUIPrimitiveComponent,
+  isHeroUIAgentAttachmentContentType,
+  itemCardComponentSchema,
+  itemCardGroupComponentSchema,
+  kpiGridComponentSchema,
+  lineChartComponentSchema,
+  listBlockComponentSchema,
+  listComponentSchema,
+  mapComponentSchema,
+  meterListComponentSchema,
+  metricGridComponentSchema,
+  numberFormatSchema,
+  pageContextSchema,
+  parseAgentRemoteConfig,
+  pieChartComponentSchema,
+  playerCardComponentSchema,
+  playlistComponentSchema,
+  productCardComponentSchema,
+  productSignalsComponentSchema,
+  progressComponentSchema,
+  purchaseCompleteComponentSchema,
+  purchaseItemsComponentSchema,
+  radarChartComponentSchema,
+  radialChartComponentSchema,
+  ratingComponentSchema,
+  recordCardComponentSchema,
+  recordCardLayoutSchema,
+  renderAgentUICatalogPrompt,
+  renderComponentInputSchema,
+  resolveAgentModelId,
+  rideStatusComponentSchema,
+  rowComponentSchema,
+  sankeyChartComponentSchema,
+  scatterChartComponentSchema,
+  signTrustedAgentClientData,
+  signedTrustedAgentClientDataSchema,
+  spacerComponentSchema,
+  stepsComponentSchema,
+  switchGroupComponentSchema,
+  tabsComponentSchema,
+  tagListComponentSchema,
+  textComponentSchema,
+  toggleGroupComponentSchema,
+  trustedAgentClientDataSchema,
+  verifyTrustedAgentClientData,
+  viewEventComponentSchema,
+  weatherConditionSchema,
+  weatherConditions,
+  weatherCurrentComponentSchema,
+  weatherForecastComponentSchema
+};