@heroui/agent 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/index.js

@@ -1 +1 @@
-import{a as m,b as a}from"./chunk-USFF5UMB.js";import"./chunk-5RHO3S5E.js";import"./chunk-6ZJJN322.js";import{a as e}from"./chunk-64RI74L5.js";import{a as t,b as n,c as o,d as r,e as A,f as g,g as i}from"./chunk-UHHKMESI.js";import{a as s}from"./chunk-7KCGPNEN.js";import{a as p}from"./chunk-4JEZZR5J.js";export{p as AGENT_DESIGN_THEMES,t as AGENT_MODEL_IDS,A as AGENT_MODEL_OPTIONS,r as DEFAULT_AGENT_PICKER_MODEL_ID,s as HEROUI_AGENT_RUNTIME_TIMING_EVENT,a as HeroUIAgent,n as LEGACY_AGENT_MODEL_IDS,e as createToolHelper,i as getAgentModelTier,g as isAgentModelId,o as resolveAgentModelId,m as useAgent};
+import{a as d,b as e}from"./chunk-MB3T5S5N.js";import"./chunk-5CSSZ76R.js";import{a as f}from"./chunk-AR424OVX.js";import{a as b,b as c}from"./chunk-23EBJXRA.js";import{a}from"./chunk-FZXNXBTZ.js";export{f as DEFAULT_MARKDOWN_ANIMATION,c as HEROUI_AGENT_API_BASE_URL,b as HEROUI_AGENT_SDK_VERSION,e as HeroUIAgent,a as createToolHelper,d as useAgent};

package/dist/internal/host.d.ts

@@ -0,0 +1,188 @@
+import { L as AgentViewMode, O as ClientToolIcon, m as AgentError, V as UploadAgentDataSourceInput, B as AgentResponseFeedback, F as AgentStatus, i as AgentController, U as HeroUIAgentProps, M as ClientTool, S as GetAuthToken } from '../types-C3g7R0hr.js';
+export { X as parseClientToolArgs, Y as resolveDirectToolAction } from '../types-C3g7R0hr.js';
+import 'react';
+
+type HostedFrameBounds = {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+};
+type HostedFrameState = {
+    bounds: HostedFrameBounds | null;
+    closing: boolean;
+    dragging: boolean;
+    expanded: boolean;
+    mounted: boolean;
+    open: boolean;
+    overlayOpen: boolean;
+    ready: boolean;
+    resizing: boolean;
+    sidebarWidth: number | null;
+    viewMode: AgentViewMode;
+};
+type HostPageLayout = {
+    active: boolean;
+    body: HTMLElement;
+    original: {
+        bodyLeft: string;
+        bodyOverflow: string;
+        bodyPosition: string;
+        bodyRight: string;
+        bodyTop: string;
+        bodyWidth: string;
+        rootMarginRight: string;
+        rootOverflow: string;
+        rootTransition: string;
+    };
+    root: HTMLElement;
+    scrollLock: {
+        x: number;
+        y: number;
+    } | null;
+};
+
+declare const HEROUI_AGENT_HOSTED_ORIGIN: "https://agent.heroui.pro";
+declare const HEROUI_AGENT_HOSTED_STAGING_ORIGIN: "https://staging-agent.heroui.pro";
+declare const HEROUI_AGENT_BRIDGE_MAX_MESSAGE_BYTES: number;
+declare const HEROUI_AGENT_BRIDGE_MAX_PERSISTENCE_BYTES: number;
+type AgentBridgeJsonValue = boolean | null | number | string | AgentBridgeJsonValue[] | {
+    [key: string]: AgentBridgeJsonValue;
+};
+type HostedAgentToolManifest = {
+    description: string;
+    displayName?: string;
+    icon?: ClientToolIcon;
+    iconColor?: string;
+    inputSchema: Record<string, unknown>;
+    name: string;
+    needsApproval?: boolean;
+};
+type HostedAgentInit = {
+    restoreSession?: boolean;
+    localStorage: Record<string, string>;
+    sessionStorage: Record<string, string>;
+    props: Record<string, unknown>;
+    tools: HostedAgentToolManifest[];
+};
+type AgentPersistenceRequest = {
+    store: "composer-image-drafts" | "message-outboxes";
+    operation: "get" | "put" | "delete" | "deletePrefix";
+    key?: string;
+    prefix?: string;
+    value?: unknown;
+};
+type AgentBridgePayloads = {
+    "host.command": {
+        name: string;
+        payload?: unknown;
+    };
+    "host.init": HostedAgentInit;
+    "host.init-error": AgentError;
+    "host.update": HostedAgentInit;
+    "host.rpc-result": {
+        value: unknown;
+    };
+    "host.rpc-error": {
+        error: string;
+        code?: string;
+    };
+    "host.upload-data-source": {
+        toolCallId: string;
+        upload: UploadAgentDataSourceInput;
+    };
+    "iframe.ready": undefined;
+    "iframe.reload": undefined;
+    "iframe.auth-request": undefined;
+    "iframe.context-request": undefined;
+    "iframe.feedback": AgentResponseFeedback;
+    "iframe.persistence": AgentPersistenceRequest;
+    "iframe.state": HostedFrameState;
+    "iframe.storage": {
+        operation: "set" | "remove" | "clear";
+        storage: "local" | "session";
+        key?: string;
+        value?: string;
+    };
+    "iframe.rpc-result": {
+        value: unknown;
+    };
+    "iframe.rpc-error": {
+        error: string;
+    };
+    "iframe.error": AgentError;
+    "iframe.status": AgentStatus;
+    "iframe.tool-cancel": {
+        idempotencyKey: string;
+    };
+    "iframe.tool-execute": {
+        args: unknown;
+        conversationId: string;
+        idempotencyKey: string;
+        name: string;
+        toolCallId: string;
+    };
+};
+type AgentBridgeMessageType = keyof AgentBridgePayloads;
+type AgentBridgeEnvelope<T extends AgentBridgeMessageType = AgentBridgeMessageType> = T extends AgentBridgeMessageType ? {
+    nonce: string;
+    payload?: AgentBridgePayloads[T];
+    requestId: string;
+    sessionId: string;
+    type: T;
+} : never;
+declare function createAgentBridgeEnvelope<T extends AgentBridgeMessageType>(sessionId: string, nonce: string, type: T, payload?: AgentBridgePayloads[T], requestId?: string): AgentBridgeEnvelope<T>;
+declare function parseAgentBridgeEnvelope(value: unknown): AgentBridgeEnvelope | null;
+declare function isAgentBridgeJsonValue(value: unknown, seen?: Set<object>): value is AgentBridgeJsonValue;
+declare function estimateAgentBridgeMessageBytes(value: unknown): number;
+
+/** Bounds even callbacks that do not cooperate with cancellation. */
+declare function abortable<T>(signal: AbortSignal, work: () => Promise<T>): Promise<T>;
+declare function withDeadline<T>(milliseconds: number, work: (signal: AbortSignal) => Promise<T>, parent?: AbortSignal): Promise<T>;
+
+declare function createAgentError(cause: unknown, phase?: AgentStatus): AgentError;
+
+type AgentHostController = AgentController & {
+    destroy: () => void;
+    subscribe: (listener: () => void) => () => void;
+    update: (options: HeroUIAgentProps) => void;
+};
+type ClientToolManifestSerializer = (tools: ClientTool[]) => HostedAgentToolManifest[] | Promise<HostedAgentToolManifest[]>;
+declare function mountAgent(initialOptions: HeroUIAgentProps, serializeTools: ClientToolManifestSerializer): AgentHostController;
+
+/**
+ * Requests a short-lived HeroUI Agent credential through the host
+ * application's server callback. Refresh and request de-duplication are
+ * handled here while the project API key remains server-only.
+ */
+declare class EmbedSessionManager {
+    private readonly agentId;
+    private readonly getAuthToken;
+    private cached;
+    private failure;
+    private generation;
+    private pending;
+    private controller;
+    constructor(agentId: string, getAuthToken: GetAuthToken);
+    clear(): void;
+    /**
+     * Forgets both the cached credential and the browser's anonymous id, so the
+     * next request represents a brand-new person. Used on logout to stop a
+     * shared device from attributing the next visitor to the previous user.
+     */
+    reset(): void;
+    get(): Promise<string>;
+    subjectHash(): Promise<string>;
+    private anonymousId;
+    private expiresAt;
+    private refresh;
+}
+
+declare class ClientToolResultError extends Error {
+    readonly code: "CLIENT_TOOL_RESULT_TOO_LARGE" | "CLIENT_TOOL_RESULT_NOT_SERIALIZABLE";
+    constructor(code: "CLIENT_TOOL_RESULT_TOO_LARGE" | "CLIENT_TOOL_RESULT_NOT_SERIALIZABLE", message: string);
+}
+/** Validate before crossing the bridge or persisting a replayable receipt. */
+declare function serializeClientToolResult(value: unknown): unknown;
+
+export { type AgentBridgeEnvelope, type AgentBridgeJsonValue, type AgentBridgeMessageType, type AgentBridgePayloads, type AgentHostController, type AgentPersistenceRequest, type ClientToolManifestSerializer, ClientToolResultError, EmbedSessionManager, HEROUI_AGENT_BRIDGE_MAX_MESSAGE_BYTES, HEROUI_AGENT_BRIDGE_MAX_PERSISTENCE_BYTES, HEROUI_AGENT_HOSTED_ORIGIN, HEROUI_AGENT_HOSTED_STAGING_ORIGIN, type HostPageLayout, type HostedAgentInit, type HostedAgentToolManifest, type HostedFrameState, abortable, createAgentBridgeEnvelope, createAgentError, estimateAgentBridgeMessageBytes, isAgentBridgeJsonValue, mountAgent, parseAgentBridgeEnvelope, serializeClientToolResult, withDeadline };

package/dist/internal/host.js

@@ -0,0 +1 @@
+import{a as r,b as t,c as l,d as a,e as i,f as n,g as s}from"../chunk-5CSSZ76R.js";import"../chunk-23EBJXRA.js";import{c as o,d as e,i as m,j as p,k as f,l as x,m as g,n as u,o as A,p as C}from"../chunk-FZXNXBTZ.js";export{i as ClientToolResultError,a as EmbedSessionManager,f as HEROUI_AGENT_BRIDGE_MAX_MESSAGE_BYTES,x as HEROUI_AGENT_BRIDGE_MAX_PERSISTENCE_BYTES,m as HEROUI_AGENT_HOSTED_ORIGIN,p as HEROUI_AGENT_HOSTED_STAGING_ORIGIN,r as abortable,g as createAgentBridgeEnvelope,l as createAgentError,C as estimateAgentBridgeMessageBytes,A as isAgentBridgeJsonValue,s as mountAgent,u as parseAgentBridgeEnvelope,o as parseClientToolArgs,e as resolveDirectToolAction,n as serializeClientToolResult,t as withDeadline};

package/dist/internal/shared.d.ts

@@ -0,0 +1,67 @@
+export { H as HEROUI_AGENT_API_BASE_URL, a as HEROUI_AGENT_SDK_VERSION } from '../version-LiwSi-9e.js';
+import { z } from 'zod';
+import { M as ClientTool } from '../types-C3g7R0hr.js';
+export { R as DEFAULT_MARKDOWN_ANIMATION } from '../types-C3g7R0hr.js';
+import 'react';
+
+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>;
+/** Descriptive server-assigned labels, never authorization or prompt context. */
+declare const agentAuthMetadataSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+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">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    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>;
+type AgentAuthIdentity = z.infer<typeof agentAuthIdentitySchema>;
+type AgentAuthProfile = z.infer<typeof agentAuthProfileSchema>;
+type AgentAuthToken = z.infer<typeof agentAuthTokenSchema>;
+type CreateAgentAuthTokenRequest = z.infer<typeof createAgentAuthTokenRequestSchema>;
+
+declare const RESERVED_AGENT_TOOL_NAMES: readonly ["readConversationHistory", "callMcpTool", "composeUI", "executeSandbox", "generateFile", "getUIComponents", "readSkill", "renderComponent", "renderDocument", "searchKnowledge", "searchMcpTools", "searchWeb"];
+declare const RESERVED_AGENT_TOOL_PREFIX = "mcp_";
+
+declare const MAX_CLIENT_TOOLS = 20;
+declare const MAX_CLIENT_TOOLS_BYTES: number;
+declare const clientToolManifestEntrySchema: z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    needsApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const clientToolsSchema: z.ZodArray<z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    name: z.ZodString;
+    needsApproval: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+type ClientToolManifestEntry = z.infer<typeof clientToolManifestEntrySchema>;
+declare function serializeClientTools(tools: ClientTool[]): ClientToolManifestEntry[];
+
+export { type AgentAuthIdentity, type AgentAuthProfile, type AgentAuthToken, type ClientToolManifestEntry, type CreateAgentAuthTokenRequest, MAX_CLIENT_TOOLS, MAX_CLIENT_TOOLS_BYTES, RESERVED_AGENT_TOOL_NAMES, RESERVED_AGENT_TOOL_PREFIX, agentAuthIdentitySchema, agentAuthMetadataSchema, agentAuthProfileSchema, agentAuthTokenSchema, agentIdentityIdSchema, clientToolManifestEntrySchema, clientToolsSchema, createAgentAuthTokenRequestSchema, serializeClientTools };

package/dist/internal/shared.js

@@ -0,0 +1 @@
+import{a as l}from"../chunk-AR424OVX.js";import{a as s,b as A}from"../chunk-23EBJXRA.js";import{a as c,b as h,c as p,d as u,e as g}from"../chunk-KFWXAD55.js";import{e as r,f as m}from"../chunk-FZXNXBTZ.js";import{z as e}from"zod";var d=new Set(["[object object]","0","anonymous","distinct_id","distinctid","email","false","guest","id","nan","none","not_authenticated","null","true","undefined"]),t=e.string().trim().min(1).max(200).refine(n=>!d.has(n.toLowerCase()),{message:"Identity id is reserved"}),o=e.discriminatedUnion("type",[e.object({id:t,type:e.literal("anonymous")}),e.object({id:t,type:e.literal("user")})]),i=e.object({avatarUrl:e.string().trim().pipe(e.url()).optional(),email:e.string().trim().max(320).pipe(e.email()).optional(),name:e.string().trim().max(120).optional()}),a=e.record(e.string(),e.string()).refine(n=>new TextEncoder().encode(JSON.stringify(n)).byteLength<=4096,{message:"Metadata must not exceed 4 KiB"}),S=e.object({anonymousId:t.optional(),identity:o,metadata:a.optional(),profile:i.optional()}),T=e.object({expiresAt:e.number().int().positive(),token:e.string().trim().min(1)});export{l as DEFAULT_MARKDOWN_ANIMATION,A as HEROUI_AGENT_API_BASE_URL,s as HEROUI_AGENT_SDK_VERSION,c as MAX_CLIENT_TOOLS,h as MAX_CLIENT_TOOLS_BYTES,r as RESERVED_AGENT_TOOL_NAMES,m as RESERVED_AGENT_TOOL_PREFIX,o as agentAuthIdentitySchema,a as agentAuthMetadataSchema,i as agentAuthProfileSchema,T as agentAuthTokenSchema,t as agentIdentityIdSchema,p as clientToolManifestEntrySchema,u as clientToolsSchema,S as createAgentAuthTokenRequestSchema,g as serializeClientTools};

package/dist/next.d.ts

@@ -1,5 +1,4 @@
-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';
+export { A as AgentApiOverrides, a as AgentAppearance, b as AgentAttachmentContentType, c as AgentAuthToken, d as AgentCapabilities, e as AgentColorScheme, f as AgentComponentExportFormat, g as AgentComposerOptions, h as AgentContext, i as AgentController, j as AgentDataSource, k as AgentDataSourceFormat, l as AgentDesignTheme, m as AgentError, n as AgentFeedbackReason, o as AgentLauncherOptions, p as AgentLauncherPosition, q as AgentMarkdownAnimation, r as AgentMarkdownAnimationOptions, s as AgentMarkdownCaret, t as AgentMarkdownOptions, u as AgentMessageAction, v as AgentModelId, w as AgentPanelOptions, x as AgentPermissionMode, y as AgentPermissionOptions, z as AgentRadius, B as AgentResponseFeedback, C as AgentSharedContext, D as AgentShouldCloseOnInteractOutside, E as AgentStartScreenOptions, F as AgentStatus, G as AgentSurfaceVariant, H as AgentThemeColor, I as AgentThemeColors, J as AgentThemeOptions, K as AgentTypography, L as AgentViewMode, M as ClientTool, N as ClientToolExecutionContext, O as ClientToolIcon, P as ClientToolStatus, Q as ClientToolVisualResult, R as DEFAULT_MARKDOWN_ANIMATION, S as GetAuthToken, T as GetAuthTokenContext, U as HeroUIAgentProps, V as UploadAgentDataSourceInput, W as createToolHelper } from './types-C3g7R0hr.js';
+export { HeroUIAgent, useAgent } from './index.js';
+export { H as HEROUI_AGENT_API_BASE_URL, a as HEROUI_AGENT_SDK_VERSION } from './version-LiwSi-9e.js';
 import 'react';
-import 'react/jsx-runtime';
-import 'zod';
-import 'streamdown';

package/dist/next.js

@@ -1 +1 @@
-import{a as i,b as p}from"./chunk-USFF5UMB.js";import"./chunk-5RHO3S5E.js";import"./chunk-6ZJJN322.js";import{a as e}from"./chunk-64RI74L5.js";import{a as t,d as n,e as o,f as r,g as A}from"./chunk-UHHKMESI.js";import{a as g}from"./chunk-7KCGPNEN.js";import"./chunk-4JEZZR5J.js";export{t as AGENT_MODEL_IDS,o as AGENT_MODEL_OPTIONS,n as DEFAULT_AGENT_PICKER_MODEL_ID,g as HEROUI_AGENT_RUNTIME_TIMING_EVENT,p as HeroUIAgent,e as createToolHelper,A as getAgentModelTier,r as isAgentModelId,i as useAgent};
+import{a as f,b as m}from"./chunk-MB3T5S5N.js";import"./chunk-5CSSZ76R.js";import{a as p}from"./chunk-AR424OVX.js";import{a as r,b as e}from"./chunk-23EBJXRA.js";import{a as o}from"./chunk-FZXNXBTZ.js";export{p as DEFAULT_MARKDOWN_ANIMATION,e as HEROUI_AGENT_API_BASE_URL,r as HEROUI_AGENT_SDK_VERSION,m as HeroUIAgent,o as createToolHelper,f as useAgent};

package/dist/persistence-YI6JSYCT.js

@@ -0,0 +1 @@
+var d="heroui-agent-host-storage";var s="records";async function k(r,t){let e=f(t),o=await w();if(!o){if(e.operation==="get")return null;throw new Error("Durable HeroUI Agent storage is unavailable")}try{if(e.operation==="deletePrefix")return await g(o,l(r,e.store,e.prefix)),null;let n=l(r,e.store,e.key),i=o.transaction(s,e.operation==="get"?"readonly":"readwrite"),a=i.objectStore(s);if(e.operation==="get"){let p=await P(a.get(n));return await u(i),p?.value??null}return e.operation==="put"?a.put({id:n,value:e.value}):a.delete(n),await u(i),null}finally{o.close()}}function f(r){if(!r||typeof r!="object")throw new Error("Invalid persistence request");let t=r,e=t.store;if(e!=="composer-image-drafts"&&e!=="message-outboxes")throw new Error("Invalid persistence store");if(t.operation==="deletePrefix"){if(!c(t.prefix))throw new Error("Invalid persistence prefix");return{operation:"deletePrefix",prefix:t.prefix,store:e}}if(t.operation!=="delete"&&t.operation!=="get"&&t.operation!=="put"||!c(t.key))throw new Error("Invalid persistence request");return t.operation==="put"?{key:t.key,operation:"put",store:e,value:t.value}:{key:t.key,operation:t.operation,store:e}}function c(r){return typeof r=="string"&&r.length>0&&r.length<=2048}function l(r,t,e){return`${r}:${t}:${e}`}function w(){return typeof indexedDB>"u"?Promise.resolve(null):new Promise((r,t)=>{let e=indexedDB.open(d,1);e.onerror=()=>t(e.error??new Error("Unable to open Agent storage")),e.onupgradeneeded=()=>{e.result.objectStoreNames.contains(s)||e.result.createObjectStore(s,{keyPath:"id"})},e.onsuccess=()=>r(e.result)})}function g(r,t){let e=r.transaction(s,"readwrite"),o=e.objectStore(s).openCursor();return o.onsuccess=()=>{let n=o.result;n&&(typeof n.key=="string"&&n.key.startsWith(t)&&n.delete(),n.continue())},u(e)}function P(r){return new Promise((t,e)=>{r.onerror=()=>e(r.error??new Error("Agent storage request failed")),r.onsuccess=()=>t(r.result)})}function u(r){return new Promise((t,e)=>{r.onabort=()=>e(r.error??new Error("Agent storage write aborted")),r.onerror=()=>e(r.error??new Error("Agent storage transaction failed")),r.oncomplete=()=>t()})}export{k as executeAgentHostPersistence};

package/dist/server.d.ts

@@ -1,5 +1,24 @@
-import { a as AgentAuthIdentity, b as AgentAuthProfile, c as AgentAuthToken } from './identity-3P8-17km.js';
-import 'zod';
+import { z } from 'zod';
+
+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>;
+declare const agentAuthTokenSchema: z.ZodObject<{
+    expiresAt: z.ZodNumber;
+    token: z.ZodString;
+}, z.core.$strip>;
+type AgentAuthIdentity = z.infer<typeof agentAuthIdentitySchema>;
+type AgentAuthProfile = z.infer<typeof agentAuthProfileSchema>;
+type AgentAuthToken = z.infer<typeof agentAuthTokenSchema>;
 
 type CreateAuthTokenOptions = {
     /**
@@ -15,6 +34,8 @@ type CreateAuthTokenOptions = {
     identity: AgentAuthIdentity;
     /** Optional end-user profile metadata shown in Agent monitoring. */
     profile?: AgentAuthProfile;
+    /** Descriptive run labels shown in Monitor. Maximum 4 KiB; never grants access. */
+    metadata?: Record<string, string>;
     agentId: string;
 };
 declare class HeroUIAgentAuthError extends Error {

package/dist/server.js

@@ -1 +1 @@
-import{z as e}from"zod";var m="1.0.0-beta.1",u="https://api.heroui.pro";var d=e.enum(["light","dark","system"]),y=e.enum(["outline","plain","surface","surface-secondary"]),f=new Set(["[object object]","0","anonymous","distinct_id","distinctid","email","false","guest","id","nan","none","not_authenticated","null","true","undefined"]),c=e.string().trim().min(1).max(200).refine(t=>!f.has(t.toLowerCase()),{message:"Identity id is reserved"}),I=e.discriminatedUnion("type",[e.object({id:c,type:e.literal("anonymous")}),e.object({id:c,type:e.literal("user")})]),S=e.object({avatarUrl:e.string().trim().pipe(e.url()).optional(),email:e.string().trim().max(320).pipe(e.email()).optional(),name:e.string().trim().max(120).optional()}),g=e.object({anonymousId:c.optional(),identity:I,profile:S.optional()}),h=e.object({expiresAt:e.number().int().positive(),token:e.string().trim().min(1)}),O=e.object({agentId:e.string().trim().min(1).max(100),apiKeyId:e.string().trim().min(1).max(100),aud:e.literal("heroui-agent"),exp:e.number().int().positive(),iat:e.number().int().positive(),iss:e.literal("https://api.heroui.com"),jti:e.uuid(),protocolVersion:e.literal(6),sub:e.string().trim().min(1).max(200)});var _=e.object({agentId:e.string(),minimumProtocolVersion:e.literal(6),name:e.string().trim().min(1).max(120),protocolVersion:e.literal(6),sdkVersion:e.string().default(m),suggestedPrompts:e.array(e.string().trim().min(1).max(160)).max(5),surfaceVariant:y.default("plain"),theme:d});var n=class extends Error{status;constructor(o,i,a){super(o,a),this.name="HeroUIAgentAuthError",this.status=i}};async function C(t){let o=t.apiKey.trim(),i=t.agentId.trim(),a=g.safeParse({anonymousId:t.anonymousId,identity:t.identity,profile:t.profile});if(!o||!i||!a.success)throw new n("Invalid HeroUI Agent auth token request",400);let l=(t.apiBaseUrl?.trim()||u).replace(/\/$/,""),r;try{r=await fetch(`${l}/v1/agents/${encodeURIComponent(i)}/auth-tokens`,{body:JSON.stringify(a.data),cache:"no-store",headers:{Accept:"application/json","Content-Type":"application/json","X-HeroUI-Agent-Key":o},method:"POST"})}catch(A){throw new n("HeroUI Agent authentication is unavailable",503,{cause:A})}if(!r.ok)throw new n("HeroUI Agent authentication failed",r.status);let p=h.safeParse(await r.json().catch(()=>null));if(!p.success)throw new n("HeroUI Agent authentication returned invalid data",502);return p.data}export{n as HeroUIAgentAuthError,C as createAuthToken};
+import{z as t}from"zod";var g=new Set(["[object object]","0","anonymous","distinct_id","distinctid","email","false","guest","id","nan","none","not_authenticated","null","true","undefined"]),s=t.string().trim().min(1).max(200).refine(e=>!g.has(e.toLowerCase()),{message:"Identity id is reserved"}),A=t.discriminatedUnion("type",[t.object({id:s,type:t.literal("anonymous")}),t.object({id:s,type:t.literal("user")})]),l=t.object({avatarUrl:t.string().trim().pipe(t.url()).optional(),email:t.string().trim().max(320).pipe(t.email()).optional(),name:t.string().trim().max(120).optional()}),y=t.record(t.string(),t.string()).refine(e=>new TextEncoder().encode(JSON.stringify(e)).byteLength<=4096,{message:"Metadata must not exceed 4 KiB"}),u=t.object({anonymousId:s.optional(),identity:A,metadata:y.optional(),profile:l.optional()}),p=t.object({expiresAt:t.number().int().positive(),token:t.string().trim().min(1)});var h="https://api.heroui.pro";var n=class extends Error{status;constructor(a,o,i){super(a,i),this.name="HeroUIAgentAuthError",this.status=o}};async function k(e){let a=e.apiKey.trim(),o=e.agentId.trim(),i=u.safeParse({anonymousId:e.anonymousId,identity:e.identity,metadata:e.metadata,profile:e.profile});if(!a||!o||!i.success)throw new n("Invalid HeroUI Agent auth token request",400);let d=(e.apiBaseUrl?.trim()||h).replace(/\/$/,""),r;try{r=await fetch(`${d}/v1/agents/${encodeURIComponent(o)}/auth-tokens`,{body:JSON.stringify(i.data),cache:"no-store",headers:{Accept:"application/json","Content-Type":"application/json","X-HeroUI-Agent-Key":a},method:"POST"})}catch(m){throw new n("HeroUI Agent authentication is unavailable",503,{cause:m})}if(!r.ok)throw new n("HeroUI Agent authentication failed",r.status);let c=p.safeParse(await r.json().catch(()=>null));if(!c.success)throw new n("HeroUI Agent authentication returned invalid data",502);return c.data}export{n as HeroUIAgentAuthError,k as createAuthToken};