@heroui/agent 0.2.0-beta.1

package/dist/interactive-map-surface-67KHT3VB.js

@@ -0,0 +1,362 @@
+"use client";
+import {
+  createMapLayout,
+  getMapSelectionCenter
+} from "./chunk-VJA52U5P.js";
+import {
+  mergeClassNames
+} from "./chunk-3FG5NRTX.js";
+
+// ../agent-ui/src/components/display-information/map/interactive-map-surface.tsx
+import { StarFill } from "@gravity-ui/icons";
+
+// ../agent-ui/src/components/display-information/map/interactive-map.tsx
+import MapLibreGL from "maplibre-gl";
+import { createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+var InteractiveMapContext = createContext(null);
+function getDocumentTheme() {
+  if (typeof document === "undefined") return void 0;
+  if (document.documentElement.classList.contains("dark") || document.documentElement.dataset["theme"] === "dark") {
+    return "dark";
+  }
+  if (document.documentElement.classList.contains("light") || document.documentElement.dataset["theme"] === "light") {
+    return "light";
+  }
+  return void 0;
+}
+function getLocalTheme(element) {
+  const themeRoot = element?.closest("[data-theme]");
+  const theme = themeRoot?.dataset["theme"];
+  return theme === "dark" || theme === "light" ? theme : void 0;
+}
+function getSystemTheme() {
+  if (typeof window === "undefined") return "light";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function useMapTheme(containerRef) {
+  const [theme, setTheme] = useState(() => getDocumentTheme() ?? getSystemTheme());
+  useEffect(() => {
+    const localThemeRoot = containerRef.current?.closest("[data-theme]");
+    const updateTheme = () => setTheme(getLocalTheme(containerRef.current) ?? getDocumentTheme() ?? getSystemTheme());
+    const observer = new MutationObserver(updateTheme);
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    updateTheme();
+    observer.observe(document.documentElement, {
+      attributeFilter: ["class", "data-theme"],
+      attributes: true
+    });
+    if (localThemeRoot && localThemeRoot !== document.documentElement) {
+      observer.observe(localThemeRoot, {
+        attributeFilter: ["data-theme"],
+        attributes: true
+      });
+    }
+    mediaQuery.addEventListener("change", updateTheme);
+    return () => {
+      observer.disconnect();
+      mediaQuery.removeEventListener("change", updateTheme);
+    };
+  }, [containerRef]);
+  return theme;
+}
+function InteractiveMapRoot({
+  center,
+  children,
+  className,
+  padding,
+  styles,
+  zoom,
+  ...options
+}) {
+  const [longitude, latitude] = center;
+  const containerRef = useRef(null);
+  const initialOptionsRef = useRef({
+    ...options,
+    center: [longitude, latitude],
+    zoom
+  });
+  const [map, setMap] = useState(null);
+  const [loadState, setLoadState] = useState("loading");
+  const theme = useMapTheme(containerRef);
+  const activeStyle = styles[theme];
+  const activeStyleRef = useRef(activeStyle);
+  const initialPaddingRef = useRef(padding);
+  const zoomRef = useRef(zoom);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const nextMap = new MapLibreGL.Map({
+      attributionControl: false,
+      container,
+      renderWorldCopies: false,
+      style: activeStyleRef.current,
+      ...initialOptionsRef.current
+    });
+    const loadTimeout = window.setTimeout(() => setLoadState("error"), 12e3);
+    const handleLoad = () => {
+      window.clearTimeout(loadTimeout);
+      setLoadState("loaded");
+    };
+    const observer = new ResizeObserver(() => nextMap.resize());
+    nextMap.touchZoomRotate.disableRotation();
+    if (initialPaddingRef.current) nextMap.setPadding(initialPaddingRef.current);
+    nextMap.on("load", handleLoad);
+    observer.observe(container);
+    setMap(nextMap);
+    return () => {
+      window.clearTimeout(loadTimeout);
+      observer.disconnect();
+      nextMap.off("load", handleLoad);
+      nextMap.remove();
+      setMap(null);
+    };
+  }, []);
+  useEffect(() => {
+    if (!map || activeStyleRef.current === activeStyle) return;
+    const styleLoadTimeout = window.setTimeout(() => setLoadState("error"), 12e3);
+    const handleStyleLoad = () => {
+      window.clearTimeout(styleLoadTimeout);
+      setLoadState("loaded");
+    };
+    const handleStyleLoading = () => setLoadState("loading");
+    activeStyleRef.current = activeStyle;
+    map.once("styledataloading", handleStyleLoading);
+    map.setStyle(activeStyle, { diff: false });
+    map.once("style.load", handleStyleLoad);
+    return () => {
+      window.clearTimeout(styleLoadTimeout);
+      map.off("style.load", handleStyleLoad);
+      map.off("styledataloading", handleStyleLoading);
+    };
+  }, [activeStyle, map]);
+  useEffect(() => {
+    if (!map) return;
+    const currentCenter = map.getCenter();
+    const centerChanged = currentCenter.lng !== longitude || currentCenter.lat !== latitude;
+    const zoomChanged = zoomRef.current !== zoom;
+    zoomRef.current = zoom;
+    if (!centerChanged && !zoomChanged) return;
+    map.easeTo({
+      center: [longitude, latitude],
+      duration: window.matchMedia("(prefers-reduced-motion: reduce)").matches ? 0 : 350,
+      ...zoomChanged ? { zoom } : {}
+    });
+  }, [latitude, longitude, map, zoom]);
+  return /* @__PURE__ */ jsx(InteractiveMapContext, { value: map, children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: mergeClassNames("aui-interactive-map", className),
+      "data-load-state": loadState,
+      "data-slot": "agent-ui-interactive-map",
+      children: [
+        loadState === "loading" ? /* @__PURE__ */ jsx("div", { "aria-label": "Loading map", className: "aui-interactive-map__loader", role: "status", children: /* @__PURE__ */ jsx("span", {}) }) : null,
+        loadState === "error" ? /* @__PURE__ */ jsxs("div", { className: "aui-interactive-map__error", role: "status", children: [
+          /* @__PURE__ */ jsx("strong", { children: "Map unavailable" }),
+          /* @__PURE__ */ jsx("span", { children: "Location results remain available." })
+        ] }) : null,
+        map ? children : null
+      ]
+    }
+  ) });
+}
+function InteractiveMapMarker({ children, latitude, longitude }) {
+  const map = useContext(InteractiveMapContext);
+  const initialPositionRef = useRef({ latitude, longitude });
+  const [marker, setMarker] = useState(null);
+  useEffect(() => {
+    const nextElement = document.createElement("div");
+    const initialPosition = initialPositionRef.current;
+    const nextMarker = new MapLibreGL.Marker({ element: nextElement }).setLngLat([
+      initialPosition.longitude,
+      initialPosition.latitude
+    ]);
+    nextElement.className = "aui-interactive-map__marker-host";
+    setMarker(nextMarker);
+    return () => {
+      nextMarker.remove();
+    };
+  }, []);
+  useEffect(() => {
+    if (!map || !marker) return;
+    marker.addTo(map);
+    const markerElement = marker.getElement();
+    markerElement.removeAttribute("aria-label");
+    markerElement.removeAttribute("role");
+    markerElement.removeAttribute("tabindex");
+    return () => {
+      marker.remove();
+    };
+  }, [map, marker]);
+  useEffect(() => {
+    marker?.setLngLat([longitude, latitude]);
+  }, [latitude, longitude, marker]);
+  return marker ? createPortal(
+    /* @__PURE__ */ jsx("div", { className: "aui-interactive-map__marker-content", children }),
+    marker.getElement()
+  ) : null;
+}
+function ControlButton({ children, label, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      "aria-label": label,
+      className: "aui-interactive-map__control-button",
+      type: "button",
+      ...props,
+      children
+    }
+  );
+}
+function PlusIcon(props) {
+  return /* @__PURE__ */ jsx("svg", { "aria-hidden": "true", fill: "none", viewBox: "0 0 16 16", ...props, children: /* @__PURE__ */ jsx("path", { d: "M8 3v10M3 8h10", stroke: "currentColor", strokeLinecap: "round", strokeWidth: "1.5" }) });
+}
+function MinusIcon(props) {
+  return /* @__PURE__ */ jsx("svg", { "aria-hidden": "true", fill: "none", viewBox: "0 0 16 16", ...props, children: /* @__PURE__ */ jsx("path", { d: "M3 8h10", stroke: "currentColor", strokeLinecap: "round", strokeWidth: "1.5" }) });
+}
+function CompassIcon(props) {
+  return /* @__PURE__ */ jsxs("svg", { "aria-hidden": "true", fill: "none", viewBox: "0 0 24 24", ...props, children: [
+    /* @__PURE__ */ jsx("path", { d: "M12 2 16 12h-4V2Z", "data-needle": "north-right" }),
+    /* @__PURE__ */ jsx("path", { d: "m12 2-4 10h4V2Z", "data-needle": "north-left" }),
+    /* @__PURE__ */ jsx("path", { d: "m12 22 4-10h-4v10Z", "data-needle": "south-right" }),
+    /* @__PURE__ */ jsx("path", { d: "m12 22-4-10h4v10Z", "data-needle": "south-left" })
+  ] });
+}
+function InteractiveMapControls() {
+  const map = useContext(InteractiveMapContext);
+  const compassRef = useRef(null);
+  const updateCompass = useCallback(() => {
+    if (!map || !compassRef.current) return;
+    compassRef.current.style.transform = `rotateX(${map.getPitch()}deg) rotateZ(${-map.getBearing()}deg)`;
+  }, [map]);
+  useEffect(() => {
+    if (!map) return;
+    map.on("pitch", updateCompass);
+    map.on("rotate", updateCompass);
+    updateCompass();
+    return () => {
+      map.off("pitch", updateCompass);
+      map.off("rotate", updateCompass);
+    };
+  }, [map, updateCompass]);
+  return /* @__PURE__ */ jsxs("div", { className: "aui-interactive-map__controls", "data-slot": "agent-ui-map-controls", children: [
+    /* @__PURE__ */ jsxs("div", { className: "aui-interactive-map__control-group", children: [
+      /* @__PURE__ */ jsx(
+        ControlButton,
+        {
+          label: "Zoom in",
+          onClick: () => map?.zoomTo(map.getZoom() + 1, { duration: 250 }),
+          children: /* @__PURE__ */ jsx(PlusIcon, {})
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        ControlButton,
+        {
+          label: "Zoom out",
+          onClick: () => map?.zoomTo(map.getZoom() - 1, { duration: 250 }),
+          children: /* @__PURE__ */ jsx(MinusIcon, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "aui-interactive-map__control-group", children: /* @__PURE__ */ jsx(
+      ControlButton,
+      {
+        label: "Reset bearing to north",
+        onClick: () => map?.resetNorthPitch({ duration: 250 }),
+        children: /* @__PURE__ */ jsx(CompassIcon, { ref: compassRef, className: "aui-interactive-map__compass" })
+      }
+    ) })
+  ] });
+}
+var InteractiveMap = Object.assign(InteractiveMapRoot, {
+  Controls: InteractiveMapControls,
+  Marker: InteractiveMapMarker
+});
+
+// ../agent-ui/src/components/display-information/map/interactive-map-surface.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var mapStyles = {
+  dark: "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json",
+  light: "https://basemaps.cartocdn.com/gl/voyager-gl-style/style.json"
+};
+var resultRailPadding = { bottom: 132, left: 0, right: 0, top: 0 };
+var ratingFormatter = new Intl.NumberFormat(void 0, {
+  maximumFractionDigits: 1,
+  minimumFractionDigits: 1
+});
+function InteractiveMapSurface({
+  component,
+  onSelect,
+  selectedLocationId
+}) {
+  const layout = createMapLayout(component);
+  const center = getMapSelectionCenter(component.locations, selectedLocationId, layout.center);
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      "aria-label": `${component.title} map with ${component.locations.length} locations`,
+      className: "aui-map__surface",
+      "data-renderer": "interactive",
+      "data-slot": "agent-ui-map-surface",
+      role: "region",
+      children: [
+        /* @__PURE__ */ jsxs2(
+          InteractiveMap,
+          {
+            center: [center.longitude, center.latitude],
+            className: "aui-map__interactive-map",
+            dragRotate: false,
+            padding: resultRailPadding,
+            pitchWithRotate: false,
+            styles: mapStyles,
+            zoom: layout.zoom,
+            children: [
+              component.locations.map((location, index) => {
+                const selected = location.id === selectedLocationId;
+                const markerLabel = location.rating !== void 0 ? ratingFormatter.format(location.rating) : location.relevance !== void 0 ? `${Math.round(location.relevance * 100)}%` : String(index + 1);
+                const accessibleLabel = `Select ${location.title} on map${location.rating === void 0 ? "" : `, rated ${ratingFormatter.format(location.rating)} out of 5`}`;
+                return /* @__PURE__ */ jsx2(
+                  InteractiveMap.Marker,
+                  {
+                    latitude: location.latitude,
+                    longitude: location.longitude,
+                    children: /* @__PURE__ */ jsxs2(
+                      "button",
+                      {
+                        "aria-label": accessibleLabel,
+                        "aria-pressed": selected,
+                        className: "aui-map__marker",
+                        "data-renderer": "interactive",
+                        "data-selected": selected,
+                        "data-slot": "agent-ui-map-marker",
+                        title: location.title,
+                        type: "button",
+                        onClick: () => onSelect(location),
+                        children: [
+                          /* @__PURE__ */ jsx2(StarFill, { "aria-hidden": "true" }),
+                          /* @__PURE__ */ jsx2("span", { children: markerLabel })
+                        ]
+                      }
+                    )
+                  },
+                  location.id
+                );
+              }),
+              /* @__PURE__ */ jsx2(InteractiveMap.Controls, {})
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs2("span", { className: "aui-map__attribution", "data-slot": "agent-ui-map-attribution", children: [
+          /* @__PURE__ */ jsx2("a", { href: "https://www.openstreetmap.org/copyright", rel: "noreferrer", target: "_blank", children: "\xA9 OpenStreetMap" }),
+          /* @__PURE__ */ jsx2("span", { "aria-hidden": "true", children: " \xB7 " }),
+          /* @__PURE__ */ jsx2("a", { href: "https://carto.com/attributions", rel: "noreferrer", target: "_blank", children: "\xA9 CARTO" })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  InteractiveMapSurface
+};

package/dist/next.d.ts

@@ -0,0 +1,4 @@
+export { AGENT_MODEL_IDS, AGENT_MODEL_OPTIONS, AgentAttachmentContentType, AgentAuthToken, AgentComposerOptions, AgentContext, AgentController, AgentFeedbackReason, AgentMarkdownAnimation, AgentMarkdownCaret, AgentMarkdownOptions, AgentMarkdownPlugins, AgentMarkdownRenderer, AgentMarkdownRendererProps, AgentModelId, AgentModelOption, AgentModelTier, AgentPermissionMode, AgentPermissionOptions, AgentResponseFeedback, AgentSharedContext, ClientTool, ClientToolIconProps, ClientToolRenderProps, ClientToolStatus, DEFAULT_AGENT_PICKER_MODEL_ID, GetAuthToken, GetAuthTokenContext, HeroUIAgent, HeroUIAgentProps, createToolHelper, getAgentModelTier, isAgentModelId, useAgent } from './index.js';
+import 'react';
+import 'zod';
+import 'streamdown';

package/dist/next.js

@@ -0,0 +1,22 @@
+import {
+  HeroUIAgent,
+  useAgent
+} from "./chunk-GDDNN2XY.js";
+import {
+  AGENT_MODEL_IDS,
+  AGENT_MODEL_OPTIONS,
+  DEFAULT_AGENT_PICKER_MODEL_ID,
+  createToolHelper,
+  getAgentModelTier,
+  isAgentModelId
+} from "./chunk-RQCTC4JB.js";
+export {
+  AGENT_MODEL_IDS,
+  AGENT_MODEL_OPTIONS,
+  DEFAULT_AGENT_PICKER_MODEL_ID,
+  HeroUIAgent,
+  createToolHelper,
+  getAgentModelTier,
+  isAgentModelId,
+  useAgent
+};

package/dist/server.d.ts

@@ -0,0 +1,31 @@
+import { a as AgentAuthIdentity, b as AgentAuthProfile, c as AgentAuthToken } from './identity-NYCXY1mT.js';
+import 'zod';
+
+type CreateAuthTokenOptions = {
+    /**
+     * Browser-scoped id from the SDK's `getAuthToken` context. Pass it alongside
+     * an identified `identity` so conversations started before login are merged
+     * into the identified user.
+     */
+    anonymousId?: string;
+    /** Optional API origin override for local development or self-hosted gateways. */
+    apiBaseUrl?: string;
+    /** Secret managed API key. This value must only be used on the server. */
+    apiKey: string;
+    identity: AgentAuthIdentity;
+    /** Optional end-user profile metadata shown in Agent monitoring. */
+    profile?: AgentAuthProfile;
+    agentId: string;
+};
+declare class HeroUIAgentAuthError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number, options?: ErrorOptions);
+}
+/**
+ * Exchanges a server-only managed API key for a short-lived browser
+ * credential. The API key and upstream response body are never included in
+ * thrown error messages.
+ */
+declare function createAuthToken(options: CreateAuthTokenOptions): Promise<AgentAuthToken>;
+
+export { type CreateAuthTokenOptions, HeroUIAgentAuthError, createAuthToken };

package/dist/server.js

@@ -0,0 +1,256 @@
+// src/contracts/identity.ts
+import { z as z3 } from "zod";
+
+// src/contracts/client-tools.ts
+import { z } 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 = z.object({
+  description: z.string().trim().min(1).max(1e3),
+  inputSchema: z.record(z.string(), z.unknown()),
+  name: z.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: z.boolean().optional()
+});
+var clientToolsSchema = z.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/models.schema.ts
+import { z as z2 } 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 AGENT_MODEL_ID_SET = new Set(AGENT_MODEL_IDS);
+
+// src/contracts/models.schema.ts
+var agentModelIdSchema = z2.preprocess(
+  (value) => typeof value === "string" ? resolveAgentModelId(value) : value,
+  z2.enum(AGENT_MODEL_IDS)
+);
+
+// src/contracts/version.ts
+var HEROUI_AGENT_PROTOCOL_VERSION = 5;
+var HEROUI_AGENT_SDK_VERSION = "0.2.0-beta.1";
+
+// src/contracts/identity.ts
+var agentThemeSchema = z3.enum(["light", "dark", "system"]);
+var agentSurfaceVariantSchema = z3.enum([
+  "outline",
+  "plain",
+  "surface",
+  "surface-secondary"
+]);
+var pageContextSchema = z3.record(z3.string().max(100), z3.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 = z3.string().trim().min(1).max(200).refine((value) => !RESERVED_IDENTITY_IDS.has(value.toLowerCase()), {
+  message: "Identity id is reserved"
+});
+var agentAuthIdentitySchema = z3.discriminatedUnion("type", [
+  z3.object({
+    id: agentIdentityIdSchema,
+    type: z3.literal("anonymous")
+  }),
+  z3.object({
+    id: agentIdentityIdSchema,
+    type: z3.literal("user")
+  })
+]);
+var agentAuthProfileSchema = z3.object({
+  avatarUrl: z3.string().trim().pipe(z3.url()).optional(),
+  email: z3.string().trim().max(320).pipe(z3.email()).optional(),
+  name: z3.string().trim().max(120).optional()
+});
+var createAgentAuthTokenRequestSchema = z3.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 = z3.object({
+  expiresAt: z3.number().int().positive(),
+  token: z3.string().trim().min(1)
+});
+var agentTokenClaimsSchema = z3.object({
+  agentId: z3.string().trim().min(1).max(100),
+  apiKeyId: z3.string().trim().min(1).max(100),
+  aud: z3.literal("heroui-agent"),
+  exp: z3.number().int().positive(),
+  iat: z3.number().int().positive(),
+  iss: z3.literal("https://api.heroui.com"),
+  jti: z3.uuid(),
+  protocolVersion: z3.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  sub: z3.string().trim().min(1).max(200)
+});
+var trustedAgentClientDataSchema = z3.object({
+  agentId: z3.string(),
+  billingLicenseId: z3.string().nullable(),
+  billingOwnerUserId: z3.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: z3.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: z3.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: z3.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: z3.boolean().optional(),
+  protocolVersion: z3.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  requestId: z3.uuid(),
+  sdkVersion: z3.string().trim().min(1).max(80),
+  signedAt: z3.number(),
+  subject: z3.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: z3.boolean().optional()
+});
+var signedTrustedAgentClientDataSchema = trustedAgentClientDataSchema.extend({
+  sig: z3.string().min(1)
+});
+var agentProjectConfigSchema = z3.object({
+  agentId: z3.string(),
+  minimumProtocolVersion: z3.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  name: z3.string().trim().min(1).max(120),
+  protocolVersion: z3.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: z3.object({ url: z3.url() }).optional(),
+  sdkVersion: z3.string().default(HEROUI_AGENT_SDK_VERSION),
+  suggestedPrompts: z3.array(z3.string().trim().min(1).max(160)).max(5),
+  surfaceVariant: agentSurfaceVariantSchema.default("plain"),
+  theme: agentThemeSchema
+});
+
+// src/server/index.ts
+var DEFAULT_API_BASE_URL = "https://api.heroui.com";
+var HeroUIAgentAuthError = class extends Error {
+  status;
+  constructor(message, status, options) {
+    super(message, options);
+    this.name = "HeroUIAgentAuthError";
+    this.status = status;
+  }
+};
+async function createAuthToken(options) {
+  const apiKey = options.apiKey.trim();
+  const agentId = options.agentId.trim();
+  const request = createAgentAuthTokenRequestSchema.safeParse({
+    anonymousId: options.anonymousId,
+    identity: options.identity,
+    profile: options.profile
+  });
+  if (!apiKey || !agentId || !request.success) {
+    throw new HeroUIAgentAuthError("Invalid HeroUI Agent auth token request", 400);
+  }
+  const apiBaseUrl = (options.apiBaseUrl?.trim() || DEFAULT_API_BASE_URL).replace(/\/$/, "");
+  let response;
+  try {
+    response = await fetch(`${apiBaseUrl}/v1/agents/${encodeURIComponent(agentId)}/auth-tokens`, {
+      body: JSON.stringify(request.data),
+      cache: "no-store",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-HeroUI-Agent-Key": apiKey
+      },
+      method: "POST"
+    });
+  } catch (cause) {
+    throw new HeroUIAgentAuthError("HeroUI Agent authentication is unavailable", 503, { cause });
+  }
+  if (!response.ok) {
+    throw new HeroUIAgentAuthError("HeroUI Agent authentication failed", response.status);
+  }
+  const parsed = agentAuthTokenSchema.safeParse(await response.json().catch(() => null));
+  if (!parsed.success) {
+    throw new HeroUIAgentAuthError("HeroUI Agent authentication returned invalid data", 502);
+  }
+  return parsed.data;
+}
+export {
+  HeroUIAgentAuthError,
+  createAuthToken
+};