@heroui/agent 0.2.0-beta.7 → 0.2.0-beta.8

package/dist/identity-3P8-17km.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+
+declare const agentThemeSchema: z.ZodEnum<{
+    dark: "dark";
+    light: "light";
+    system: "system";
+}>;
+declare const agentSurfaceVariantSchema: z.ZodEnum<{
+    surface: "surface";
+    outline: "outline";
+    plain: "plain";
+    "surface-secondary": "surface-secondary";
+}>;
+declare const agentIdentityIdSchema: z.ZodString;
+declare const agentAuthIdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"anonymous">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"user">;
+}, z.core.$strip>], "type">;
+declare const agentAuthProfileSchema: z.ZodObject<{
+    avatarUrl: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodURL>>;
+    email: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodEmail>>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Server-to-server request for a short-lived browser credential. */
+declare const createAgentAuthTokenRequestSchema: z.ZodObject<{
+    anonymousId: z.ZodOptional<z.ZodString>;
+    identity: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"anonymous">;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"user">;
+    }, z.core.$strip>], "type">;
+    profile: z.ZodOptional<z.ZodObject<{
+        avatarUrl: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodURL>>;
+        email: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodEmail>>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const agentAuthTokenSchema: z.ZodObject<{
+    expiresAt: z.ZodNumber;
+    token: z.ZodString;
+}, z.core.$strip>;
+declare const agentTokenClaimsSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    apiKeyId: z.ZodString;
+    aud: z.ZodLiteral<"heroui-agent">;
+    exp: z.ZodNumber;
+    iat: z.ZodNumber;
+    iss: z.ZodLiteral<"https://api.heroui.com">;
+    jti: z.ZodUUID;
+    protocolVersion: z.ZodLiteral<6>;
+    sub: z.ZodString;
+}, z.core.$strip>;
+/**
+ * How a persisted conversation was started. Rows written before this existed
+ * carry no source and are treated as `embed`.
+ */
+declare const AGENT_CONVERSATION_SOURCE: {
+    readonly embed: "embed";
+    readonly preview: "preview";
+};
+type AgentConversationSource = (typeof AGENT_CONVERSATION_SOURCE)[keyof typeof AGENT_CONVERSATION_SOURCE];
+declare const agentProjectConfigSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    minimumProtocolVersion: z.ZodLiteral<6>;
+    name: z.ZodString;
+    protocolVersion: z.ZodLiteral<6>;
+    sdkVersion: z.ZodDefault<z.ZodString>;
+    suggestedPrompts: z.ZodArray<z.ZodString>;
+    surfaceVariant: z.ZodDefault<z.ZodEnum<{
+        surface: "surface";
+        outline: "outline";
+        plain: "plain";
+        "surface-secondary": "surface-secondary";
+    }>>;
+    theme: z.ZodEnum<{
+        dark: "dark";
+        light: "light";
+        system: "system";
+    }>;
+}, z.core.$strip>;
+type AgentAuthIdentity = z.infer<typeof agentAuthIdentitySchema>;
+type AgentAuthProfile = z.infer<typeof agentAuthProfileSchema>;
+type AgentAuthToken = z.infer<typeof agentAuthTokenSchema>;
+type CreateAgentAuthTokenRequest = z.infer<typeof createAgentAuthTokenRequestSchema>;
+type AgentTokenClaims = z.infer<typeof agentTokenClaimsSchema>;
+type AgentTheme = z.infer<typeof agentThemeSchema>;
+type AgentSurfaceVariant = z.infer<typeof agentSurfaceVariantSchema>;
+type AgentProjectConfig = z.infer<typeof agentProjectConfigSchema>;
+
+export { AGENT_CONVERSATION_SOURCE as A, type CreateAgentAuthTokenRequest as C, type AgentAuthIdentity as a, type AgentAuthProfile as b, type AgentAuthToken as c, type AgentConversationSource as d, type AgentProjectConfig as e, type AgentSurfaceVariant as f, type AgentTheme as g, type AgentTokenClaims as h, agentAuthIdentitySchema as i, agentAuthProfileSchema as j, agentAuthTokenSchema as k, agentIdentityIdSchema as l, agentProjectConfigSchema as m, agentSurfaceVariantSchema as n, agentThemeSchema as o, agentTokenClaimsSchema as p, createAgentAuthTokenRequestSchema as q };

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { ComponentType, ReactNode, CSSProperties } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import { z } from 'zod';
 import { AnimateOptions, CustomRenderer, CustomRendererProps } from 'streamdown';
 
@@ -30,6 +31,16 @@ type ClientToolSchema<TArgs> = {
     parse: (input: unknown) => TArgs;
     safeParse: (input: unknown) => unknown;
 };
+/**
+ * Stable identity for one agent-initiated browser tool effect. Pass
+ * `idempotencyKey` through to mutation APIs so an ambiguous network retry can
+ * return the original result instead of applying the side effect twice.
+ */
+type ClientToolExecutionContext = Readonly<{
+    conversationId: string;
+    idempotencyKey: string;
+    toolCallId: string;
+}>;
 /**
  * A tool the agent can call in the user's browser. Execution and rendering
  * never leave the page — only the name, description, schema, and approval
@@ -39,7 +50,7 @@ type ClientTool<TArgs = any, TContext = any> = {
     description: string;
     /** Human-readable name shown in the default tool card. Defaults to `name`. */
     displayName?: string;
-    execute: (args: TArgs, context: TContext) => Promise<unknown> | unknown;
+    execute: (args: TArgs, context: TContext, execution: ClientToolExecutionContext) => Promise<unknown> | unknown;
     /** Icon component for the default tool card ({size, color, stroke} props). */
     icon?: ComponentType<ClientToolIconProps>;
     iconColor?: string;
@@ -98,6 +109,22 @@ declare const agentThemeSchema: z.ZodEnum<{
 }>;
 type AgentTheme = z.infer<typeof agentThemeSchema>;
 
+/** Browser event emitted when protocol-v6 runtime latency checkpoints arrive. */
+declare const HEROUI_AGENT_RUNTIME_TIMING_EVENT: "heroui-agent:runtime-timing";
+type AgentActivityPhase = "accepted" | "preparing" | "generating" | "waiting-client-tool" | "running-server-tool" | "recovering";
+type AgentRuntimeTiming = {
+    completedAt?: number;
+    firstSemanticTextAt?: number;
+    providerFirstEventAt?: number;
+    providerRequestedAt?: number;
+    runtimeAdmittedAt?: number;
+    turnId?: string;
+};
+type AgentRuntimeTimingEventDetail = AgentRuntimeTiming & {
+    agentId: string;
+    conversationId: string;
+};
+
 /**
  * Deliberately Zod-free: the model catalogue is re-exported from the package
  * root, so importing Zod here would pull the whole validation library into the
@@ -296,7 +323,7 @@ type AgentMarkdownPlugins = {
 type AgentMarkdownOptions = {
     /**
      * Animate newly streamed content. Pass `false` to disable text animation.
-     * @default {animation: "blurIn", duration: 160, easing: "ease-out", sep: "word", stagger: 18}
+     * @default {animation: "fadeIn", duration: 160, easing: "ease-out", sep: "word", stagger: 18}
      */
     animated?: AgentMarkdownAnimation;
     /** Streaming caret style. Pass `false` to hide it. @default "block" */
@@ -511,14 +538,20 @@ type HeroUIAgentProps = {
      * include structured reasons and an optional comment from the feedback popover.
      */
     onFeedback?: (feedback: AgentResponseFeedback) => Promise<void> | void;
+    /**
+     * Fires whenever project configuration and the complete composer are ready
+     * for the current conversation. Use `useAgent().ready` when a custom launcher
+     * also needs the status reactively.
+     */
+    onReady?: () => void;
     /** Client-tool approval defaults and optional end-user picker. */
     permissions?: AgentPermissionOptions;
     /**
-     * Warm the agent up before the visitor touches it: fetch the chat engine,
-     * bootstrap the conversation, and boot the agent run — all while the panel is
-     * still closed, at the browser's idle priority so it never competes with your
-     * page's own loading. The first open is then immediate instead of showing a
-     * loading state.
+     * Warm the agent before the visitor touches it: fetch the chat engine,
+     * configuration, and credentials, then bootstrap and preconnect the runtime
+     * while the panel is still closed. Work starts immediately and in parallel
+     * so readiness follows the launcher as quickly as possible. Opening before
+     * then shows the Agent shell with a loading state.
      *
      * Set to `false` to request nothing until the panel is opened. Worth doing
      * when most visitors never open the agent, or on pages where you want to
@@ -574,7 +607,8 @@ type HeroUIAgentProps = {
 };
 type AgentController = {
     hide: () => void;
-    newConversation: () => void;
+    /** Start a fresh conversation, optionally submitting its first prompt immediately. */
+    newConversation: (prompt?: string) => void;
     /**
      * Warm the agent now, without opening it — the same work the `preload` prop
      * does on its own. Pair it with `preload={false}` to pick the moment from
@@ -582,6 +616,8 @@ type AgentController = {
      * struggling with. Cheap to call repeatedly; the work happens once.
      */
     preload: () => void;
+    /** Whether project configuration and the complete composer are ready to open. */
+    ready: boolean;
     refreshAuth: () => void;
     show: () => void;
     shutdown: () => void;
@@ -607,6 +643,6 @@ declare function useAgent(agentId?: string): AgentController;
  * Renders nothing in the tree; the launcher and chat panel mount into an
  * independent React root on `document.body`.
  */
-declare function HeroUIAgent(props: HeroUIAgentProps): null;
+declare function HeroUIAgent(props: HeroUIAgentProps): react_jsx_runtime.JSX.Element;
 
-export { AGENT_DESIGN_THEMES, AGENT_MODEL_IDS, AGENT_MODEL_OPTIONS, type AgentApiOverrides, type AgentAppearance, type AgentAttachmentContentType, type AgentAuthToken, type AgentCapabilities, type AgentColorScheme, type AgentComponentExportFormat, type AgentComposerOptions, type AgentContext, type AgentController, type AgentDesignTheme, type AgentFeedbackReason, type AgentLauncherOptions, type AgentLauncherPosition, type AgentMarkdownAnimation, type AgentMarkdownCaret, type AgentMarkdownOptions, type AgentMarkdownPlugins, type AgentMarkdownRenderer, type AgentMarkdownRendererProps, type AgentMessageAction, type AgentModelId, type AgentModelOption, type AgentModelTier, type AgentPanelOptions, type AgentPermissionMode, type AgentPermissionOptions, type AgentRadius, type AgentResponseFeedback, type AgentSharedContext, type AgentStartScreenOptions, type AgentThemeColor, type AgentThemeColors, type AgentThemeOptions, type AgentTypography, type AgentViewMode, type ClientTool, type ClientToolIconProps, type ClientToolRenderProps, type ClientToolStatus, DEFAULT_AGENT_PICKER_MODEL_ID, type GetAuthToken, type GetAuthTokenContext, HeroUIAgent, type HeroUIAgentProps, LEGACY_AGENT_MODEL_IDS, createToolHelper, getAgentModelTier, isAgentModelId, resolveAgentModelId, useAgent };
+export { AGENT_DESIGN_THEMES, AGENT_MODEL_IDS, AGENT_MODEL_OPTIONS, type AgentActivityPhase, type AgentApiOverrides, type AgentAppearance, type AgentAttachmentContentType, type AgentAuthToken, type AgentCapabilities, type AgentColorScheme, type AgentComponentExportFormat, type AgentComposerOptions, type AgentContext, type AgentController, type AgentDesignTheme, type AgentFeedbackReason, type AgentLauncherOptions, type AgentLauncherPosition, type AgentMarkdownAnimation, type AgentMarkdownCaret, type AgentMarkdownOptions, type AgentMarkdownPlugins, type AgentMarkdownRenderer, type AgentMarkdownRendererProps, type AgentMessageAction, type AgentModelId, type AgentModelOption, type AgentModelTier, type AgentPanelOptions, type AgentPermissionMode, type AgentPermissionOptions, type AgentRadius, type AgentResponseFeedback, type AgentRuntimeTiming, type AgentRuntimeTimingEventDetail, type AgentSharedContext, type AgentStartScreenOptions, type AgentThemeColor, type AgentThemeColors, type AgentThemeOptions, type AgentTypography, type AgentViewMode, type ClientTool, type ClientToolExecutionContext, type ClientToolIconProps, type ClientToolRenderProps, type ClientToolStatus, DEFAULT_AGENT_PICKER_MODEL_ID, type GetAuthToken, type GetAuthTokenContext, HEROUI_AGENT_RUNTIME_TIMING_EVENT, HeroUIAgent, type HeroUIAgentProps, LEGACY_AGENT_MODEL_IDS, createToolHelper, getAgentModelTier, isAgentModelId, resolveAgentModelId, useAgent };

package/dist/index.js

@@ -1,23 +1,26 @@
 import {
   HeroUIAgent,
   useAgent
-} from "./chunk-V5S5FRGV.js";
+} from "./chunk-CMZDZGUZ.js";
 import {
   AGENT_DESIGN_THEMES,
   AGENT_MODEL_IDS,
   AGENT_MODEL_OPTIONS,
   DEFAULT_AGENT_PICKER_MODEL_ID,
+  HEROUI_AGENT_RUNTIME_TIMING_EVENT,
   LEGACY_AGENT_MODEL_IDS,
   createToolHelper,
   getAgentModelTier,
   isAgentModelId,
   resolveAgentModelId
-} from "./chunk-OQGXZY5L.js";
+} from "./chunk-W7SCMB3O.js";
+import "./chunk-Q7LGTVBL.js";
 export {
   AGENT_DESIGN_THEMES,
   AGENT_MODEL_IDS,
   AGENT_MODEL_OPTIONS,
   DEFAULT_AGENT_PICKER_MODEL_ID,
+  HEROUI_AGENT_RUNTIME_TIMING_EVENT,
   HeroUIAgent,
   LEGACY_AGENT_MODEL_IDS,
   createToolHelper,

package/dist/next.d.ts

@@ -1,4 +1,5 @@
-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';
+export { AGENT_MODEL_IDS, AGENT_MODEL_OPTIONS, AgentActivityPhase, AgentAttachmentContentType, AgentAuthToken, AgentComposerOptions, AgentContext, AgentController, AgentFeedbackReason, AgentMarkdownAnimation, AgentMarkdownCaret, AgentMarkdownOptions, AgentMarkdownPlugins, AgentMarkdownRenderer, AgentMarkdownRendererProps, AgentModelId, AgentModelOption, AgentModelTier, AgentPermissionMode, AgentPermissionOptions, AgentResponseFeedback, AgentRuntimeTiming, AgentRuntimeTimingEventDetail, AgentSharedContext, ClientTool, ClientToolExecutionContext, ClientToolIconProps, ClientToolRenderProps, ClientToolStatus, DEFAULT_AGENT_PICKER_MODEL_ID, GetAuthToken, GetAuthTokenContext, HEROUI_AGENT_RUNTIME_TIMING_EVENT, HeroUIAgent, HeroUIAgentProps, createToolHelper, getAgentModelTier, isAgentModelId, useAgent } from './index.js';
 import 'react';
+import 'react/jsx-runtime';
 import 'zod';
 import 'streamdown';

package/dist/next.js

@@ -1,19 +1,22 @@
 import {
   HeroUIAgent,
   useAgent
-} from "./chunk-V5S5FRGV.js";
+} from "./chunk-CMZDZGUZ.js";
 import {
   AGENT_MODEL_IDS,
   AGENT_MODEL_OPTIONS,
   DEFAULT_AGENT_PICKER_MODEL_ID,
+  HEROUI_AGENT_RUNTIME_TIMING_EVENT,
   createToolHelper,
   getAgentModelTier,
   isAgentModelId
-} from "./chunk-OQGXZY5L.js";
+} from "./chunk-W7SCMB3O.js";
+import "./chunk-Q7LGTVBL.js";
 export {
   AGENT_MODEL_IDS,
   AGENT_MODEL_OPTIONS,
   DEFAULT_AGENT_PICKER_MODEL_ID,
+  HEROUI_AGENT_RUNTIME_TIMING_EVENT,
   HeroUIAgent,
   createToolHelper,
   getAgentModelTier,

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { a as AgentAuthIdentity, b as AgentAuthProfile, c as AgentAuthToken } from './identity-Z6i6pL0F.js';
+import { a as AgentAuthIdentity, b as AgentAuthProfile, c as AgentAuthToken } from './identity-3P8-17km.js';
 import 'zod';
 
 type CreateAuthTokenOptions = {

package/dist/server.js

@@ -1,82 +1,18 @@
 // 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.7";
+var HEROUI_AGENT_PROTOCOL_VERSION = 6;
+var HEROUI_AGENT_SDK_VERSION = "0.2.0-beta.8";
 
 // src/contracts/identity.ts
-var agentThemeSchema = z3.enum(["light", "dark", "system"]);
-var agentSurfaceVariantSchema = z3.enum([
+var agentThemeSchema = z.enum(["light", "dark", "system"]);
+var agentSurfaceVariantSchema = z.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",
@@ -94,25 +30,25 @@ var RESERVED_IDENTITY_IDS = /* @__PURE__ */ new Set([
   "true",
   "undefined"
 ]);
-var agentIdentityIdSchema = z3.string().trim().min(1).max(200).refine((value) => !RESERVED_IDENTITY_IDS.has(value.toLowerCase()), {
+var agentIdentityIdSchema = z.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({
+var agentAuthIdentitySchema = z.discriminatedUnion("type", [
+  z.object({
     id: agentIdentityIdSchema,
-    type: z3.literal("anonymous")
+    type: z.literal("anonymous")
   }),
-  z3.object({
+  z.object({
     id: agentIdentityIdSchema,
-    type: z3.literal("user")
+    type: z.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 agentAuthProfileSchema = z.object({
+  avatarUrl: z.string().trim().pipe(z.url()).optional(),
+  email: z.string().trim().max(320).pipe(z.email()).optional(),
+  name: z.string().trim().max(120).optional()
 });
-var createAgentAuthTokenRequestSchema = z3.object({
+var createAgentAuthTokenRequestSchema = z.object({
   /**
    * Browser-scoped id the SDK passed to the host callback. Sending it together
    * with an identified `identity` merges that anonymous person's conversations
@@ -122,88 +58,28 @@ var createAgentAuthTokenRequestSchema = z3.object({
   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(),
-  /**
-   * When web search is enabled, allow recent news results via `includeNews`.
-   * Optional and disabled when omitted so older signed payloads remain valid.
-   */
-  newsSearch: z3.boolean().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, images, and optionally news. Optional (not defaulted) so schema
-   * parsing never injects a field into an already-signed payload.
-   */
-  webSearch: z3.boolean().optional()
+var agentAuthTokenSchema = z.object({
+  expiresAt: z.number().int().positive(),
+  token: z.string().trim().min(1)
 });
-var signedTrustedAgentClientDataSchema = trustedAgentClientDataSchema.extend({
-  sig: z3.string().min(1)
+var agentTokenClaimsSchema = z.object({
+  agentId: z.string().trim().min(1).max(100),
+  apiKeyId: z.string().trim().min(1).max(100),
+  aud: z.literal("heroui-agent"),
+  exp: z.number().int().positive(),
+  iat: z.number().int().positive(),
+  iss: z.literal("https://api.heroui.com"),
+  jti: z.uuid(),
+  protocolVersion: z.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  sub: z.string().trim().min(1).max(200)
 });
-var agentProjectConfigSchema = z3.object({
-  agentId: z3.string(),
-  minimumProtocolVersion: z3.literal(HEROUI_AGENT_PROTOCOL_VERSION),
-  name: z3.string().trim().min(1).max(120),
-  /**
-   * InstantDB app used for ephemeral live-conversation presence. Optional so
-   * newer SDKs remain compatible with older Agent API deployments.
-   */
-  presence: z3.object({ appId: z3.uuid() }).optional(),
-  protocolVersion: z3.literal(HEROUI_AGENT_PROTOCOL_VERSION),
-  sdkVersion: z3.string().default(HEROUI_AGENT_SDK_VERSION),
-  suggestedPrompts: z3.array(z3.string().trim().min(1).max(160)).max(5),
+var agentProjectConfigSchema = z.object({
+  agentId: z.string(),
+  minimumProtocolVersion: z.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  name: z.string().trim().min(1).max(120),
+  protocolVersion: z.literal(HEROUI_AGENT_PROTOCOL_VERSION),
+  sdkVersion: z.string().default(HEROUI_AGENT_SDK_VERSION),
+  suggestedPrompts: z.array(z.string().trim().min(1).max(160)).max(5),
   surfaceVariant: agentSurfaceVariantSchema.default("plain"),
   theme: agentThemeSchema
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroui/agent",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.8",
   "description": "Embed a hosted HeroUI Agent that turns application data into interactive UI.",
   "homepage": "https://www.heroui.com/agents",
   "bugs": {
@@ -66,13 +66,13 @@
   },
   "dependencies": {
     "@ai-sdk/react": "4.0.12",
+    "@cloudflare/ai-chat": "0.10.1",
     "@gravity-ui/icons": "2.18.0",
     "@heroui/react": "3.2.2",
-    "@instantdb/core": "1.0.49",
     "@internationalized/date": "3.12.2",
     "@react-aria/utils": "3.34.1",
     "@react-stately/utils": "3.12.1",
-    "@trigger.dev/sdk": "4.5.7",
+    "agents": "0.20.1",
     "ai": "7.0.11",
     "maplibre-gl": "5.24.0",
     "motion": "12.38.0",