@heroui/agent 0.2.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,594 @@
+import { ComponentType, ReactNode, CSSProperties } from 'react';
+import { z } from 'zod';
+import { AnimateOptions, CustomRenderer, CustomRendererProps } from 'streamdown';
+
+/**
+ * Deliberately Zod-free: `createToolHelper` and these types are re-exported from
+ * the package root, which the panel shell is served from. The manifest
+ * serializer that does need Zod lives in `./client-tools-manifest`.
+ */
+type ClientToolStatus = "input-streaming" | "approval-requested" | "executing" | "completed" | "rejected" | "error";
+type ClientToolIconProps = {
+    color?: string;
+    size?: number | string;
+    stroke?: number | string;
+};
+type ClientToolRenderProps<TArgs = unknown> = {
+    /** Arguments the agent passed to the tool (typed when using Zod). */
+    args: TArgs;
+    /** Error message, present when `status === "error"`. */
+    error?: string;
+    /** Approve the call. Present when `status === "approval-requested"`. */
+    onApprove?: () => void;
+    /** Reject the call. Present when `status === "approval-requested"`. */
+    onReject?: () => void;
+    /** Return value of `execute`, present when `status === "completed"`. */
+    result?: unknown;
+    status: ClientToolStatus;
+};
+type ClientToolSchema<TArgs> = {
+    parse: (input: unknown) => TArgs;
+    safeParse: (input: unknown) => unknown;
+};
+/**
+ * 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
+ * flag are shared with the hosted agent.
+ */
+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;
+    /** Icon component for the default tool card ({size, color, stroke} props). */
+    icon?: ComponentType<ClientToolIconProps>;
+    iconColor?: string;
+    name: string;
+    /** When true, the user must approve the call before `execute` runs. */
+    needsApproval?: boolean;
+    /** Zod schema (typed) or raw JSON Schema object for the tool parameters. */
+    parameters: ClientToolSchema<TArgs> | Record<string, unknown>;
+    /**
+     * Replace the default tool card. Return `null` for any status to fall back
+     * to the default card for that state.
+     */
+    render?: (props: ClientToolRenderProps<TArgs>) => ReactNode;
+};
+/**
+ * Returns a type-safe tool factory bound to your shared context type:
+ *
+ * ```ts
+ * type AppContext = {apiClient: ApiClient};
+ * const tool = createToolHelper<AppContext>();
+ * const tools = [tool({name: "search_users", parameters: z.object({...}), execute: (args, ctx) => ...})];
+ * ```
+ */
+declare function createToolHelper<TContext>(): <TArgs>(definition: ClientTool<TArgs, TContext>) => ClientTool<TArgs, TContext>;
+
+type MessageActionKind = "copy" | "feedback" | "retry";
+type MessageFeedbackReason = "did_not_follow_instructions" | "incomplete" | "incorrect" | "not_relevant" | "other" | "unclear";
+
+/** How browser client-tool calls are approved before they execute. */
+type AgentPermissionMode$1 = "ask" | "auto" | "full";
+
+/**
+ * File types that the hosted model pipeline can process consistently.
+ *
+ * SVG and office/archive formats are intentionally excluded: SVG can carry
+ * active content, while provider support for zipped document formats varies.
+ */
+declare const HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE: {
+    readonly "application/json": "json";
+    readonly "application/pdf": "pdf";
+    readonly "image/gif": "gif";
+    readonly "image/jpeg": "jpg";
+    readonly "image/png": "png";
+    readonly "image/webp": "webp";
+    readonly "text/csv": "csv";
+    readonly "text/markdown": "md";
+    readonly "text/plain": "txt";
+    readonly "text/tab-separated-values": "tsv";
+};
+type HeroUIAgentAttachmentContentType = keyof typeof HEROUI_AGENT_ATTACHMENT_EXTENSION_BY_CONTENT_TYPE;
+
+declare const agentThemeSchema: z.ZodEnum<{
+    dark: "dark";
+    light: "light";
+    system: "system";
+}>;
+type AgentTheme = z.infer<typeof agentThemeSchema>;
+
+/**
+ * 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
+ * panel shell's first-paint graph. The matching schema lives in
+ * `./models.schema`, which only server and contract consumers need.
+ */
+/** Model ids the hosted agent accepts from the browser picker. */
+declare const AGENT_MODEL_IDS: readonly ["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"];
+type AgentModelId = (typeof AGENT_MODEL_IDS)[number];
+/**
+ * Retired ids mapped to their replacement. Model ids are a public part of the
+ * embed API — a customer pins one in their own code and projects store one as
+ * their default — so a retired id keeps resolving instead of failing the
+ * session with an "Invalid agent model" error.
+ */
+declare const LEGACY_AGENT_MODEL_IDS: Record<string, AgentModelId>;
+/** Resolves a possibly-retired model id to the id the runtime should use. */
+declare function resolveAgentModelId(value: string): string;
+type AgentModelTier = "codegen" | "complex" | "light";
+type AgentModelOption = {
+    description: string;
+    id: AgentModelId;
+    label: string;
+    provider: "Anthropic" | "Google" | "Moonshot AI" | "OpenAI";
+    tier: AgentModelTier;
+};
+/**
+ * Recommended default selected when the optional picker first opens. Luna
+ * matches the hosted runtime's baked-in default (`DEFAULT_CHAT_MODEL_IDS.herouiAgent`),
+ * so what users see in the picker is what actually runs by default.
+ */
+declare const DEFAULT_AGENT_PICKER_MODEL_ID = "openai/gpt-5.6-luna";
+/**
+ * Small, tool-capable model catalog for HeroUI Agent. These ids are the
+ * server-side allowlist as well as the browser picker source of truth.
+ */
+declare const AGENT_MODEL_OPTIONS: readonly [{
+    readonly description: "Flagship model for coding, reasoning, and knowledge work";
+    readonly id: "moonshotai/Kimi-K3";
+    readonly label: "Kimi K3";
+    readonly provider: "Moonshot AI";
+    readonly tier: "light";
+}, {
+    readonly description: "Fast answers and lightweight agent workflows";
+    readonly id: "openai/gpt-5.6-luna";
+    readonly label: "GPT-5.6 Luna";
+    readonly provider: "OpenAI";
+    readonly tier: "light";
+}, {
+    readonly description: "Balanced reasoning for everyday agent tasks";
+    readonly id: "openai/gpt-5.6-terra";
+    readonly label: "GPT-5.6 Terra";
+    readonly provider: "OpenAI";
+    readonly tier: "codegen";
+}, {
+    readonly description: "Deep reasoning for complex, multi-step analysis";
+    readonly id: "openai/gpt-5.6-sol";
+    readonly label: "GPT-5.6 Sol";
+    readonly provider: "OpenAI";
+    readonly tier: "complex";
+}, {
+    readonly description: "Fast multimodal analysis with a large context window";
+    readonly id: "google/gemini-3.6-flash";
+    readonly label: "Gemini 3.6 Flash";
+    readonly provider: "Google";
+    readonly tier: "light";
+}, {
+    readonly description: "Strong agentic reasoning and polished UI decisions";
+    readonly id: "anthropic/claude-sonnet-5";
+    readonly label: "Claude Sonnet 5";
+    readonly provider: "Anthropic";
+    readonly tier: "codegen";
+}, {
+    readonly description: "Highest-capability Claude for difficult research and analysis";
+    readonly id: "anthropic/claude-opus-4.8";
+    readonly label: "Claude Opus 4.8";
+    readonly provider: "Anthropic";
+    readonly tier: "complex";
+}];
+declare function isAgentModelId(value: unknown): value is AgentModelId;
+/** Unknown/env-overridden models keep the hosted agent's historical light tier. */
+declare function getAgentModelTier(modelId?: string): AgentModelTier;
+
+/**
+ * Light/dark color scheme selection for the embed. `"system"` follows the
+ * OS preference and updates live when it changes.
+ */
+type AgentColorScheme = AgentTheme;
+/**
+ * A theme color value: one CSS color applied to both schemes, or separate
+ * values per scheme. Tokens left unset fall back to the built-in defaults of
+ * each scheme, so overriding a light color never degrades dark mode.
+ */
+type AgentThemeColor = string | {
+    dark?: string;
+    light?: string;
+};
+/** Corner rounding preset applied across the embed surface and fields. */
+type AgentRadius = "pill" | "round" | "sharp" | "soft";
+/**
+ * The seven high-impact color tokens. Everything else in the embed
+ * (borders, shadows, chart palettes) derives from these and from the
+ * built-in scheme defaults.
+ */
+type AgentThemeColors = {
+    /** Primary action and highlight color. Chart palettes derive from it. */
+    accent?: AgentThemeColor;
+    /** Chat panel background. */
+    background?: AgentThemeColor;
+    /** Primary text color. */
+    foreground?: AgentThemeColor;
+    /** Dropdown and popover surface color. */
+    overlay?: AgentThemeColor;
+    /** Card surface color. */
+    surface?: AgentThemeColor;
+    /** Secondary surface color (chips, muted fills). */
+    surfaceSecondary?: AgentThemeColor;
+    /** Tooltip surface color. Text contrast is derived automatically. */
+    tooltip?: AgentThemeColor;
+};
+type AgentTypography = {
+    /**
+     * Base font size in pixels (clamped to 12–18).
+     * @default 14
+     */
+    baseSize?: number;
+    /** CSS font family stack, e.g. `"Geist, sans-serif"`. */
+    fontFamily?: string;
+};
+/**
+ * HeroUI Pro theme variant applied to the agent surface.
+ *
+ * Anything other than `"base"` also needs its stylesheet loaded once, from the
+ * licensed Pro package: `import "@heroui-pro/react/agent-themes/glass"`.
+ */
+type AgentDesignTheme = "base" | "brutalism" | "glass" | "mouve";
+declare const AGENT_DESIGN_THEMES: readonly AgentDesignTheme[];
+/**
+ * Intentionally small theme surface: one color scheme, one Pro variant, four
+ * radius presets, seven color tokens, and basic typography. No named themes,
+ * extend chains, or per-component tokens.
+ */
+type AgentThemeOptions = {
+    /** @default "system" */
+    colorScheme?: AgentColorScheme;
+    colors?: AgentThemeColors;
+    /**
+     * HeroUI Pro theme variant. Requires the matching stylesheet import.
+     * @default "base"
+     */
+    designTheme?: AgentDesignTheme;
+    /** @default "round" */
+    radius?: AgentRadius;
+    typography?: AgentTypography;
+};
+
+type AgentComponentExportFormat = "csv" | "png" | "svg";
+type AgentPermissionMode = AgentPermissionMode$1;
+/** MIME type accepted by the hosted HeroUI Agent attachment pipeline. */
+type AgentAttachmentContentType = HeroUIAgentAttachmentContentType;
+type AgentMessageAction = MessageActionKind;
+type AgentFeedbackReason = MessageFeedbackReason;
+type AgentResponseFeedback = {
+    /** Optional free-form context supplied by the end user. */
+    comment?: string;
+    conversationId: string;
+    messageId: string;
+    rating: "negative" | "positive";
+    /** Structured reasons selected for negative feedback. Empty for positive feedback. */
+    reasons: AgentFeedbackReason[];
+};
+type AgentContext = Record<string, unknown>;
+/**
+ * The single shared context object. It is passed as the second argument to
+ * every client tool's `execute` — API clients, user info, state setters.
+ * Anything goes; it never leaves the browser.
+ *
+ * One key is reserved: `page`. When present, the SDK calls it on every turn
+ * and sends its JSON-serializable return value (route, filters, selection —
+ * max 16KB) to the agent as page context. Nothing else in the context object
+ * ever crosses the wire.
+ */
+type AgentSharedContext = {
+    page?: () => AgentContext | Promise<AgentContext>;
+} & Record<string, unknown>;
+type AgentViewMode = "floating" | "sidebar";
+type AgentMarkdownAnimation = boolean | AnimateOptions;
+type AgentMarkdownCaret = "block" | "circle";
+type AgentMarkdownRenderer = CustomRenderer;
+type AgentMarkdownRendererProps = CustomRendererProps;
+type AgentMarkdownPlugins = {
+    /** Custom renderers selected by fenced-code language. */
+    renderers?: AgentMarkdownRenderer[];
+};
+/** Streaming Markdown presentation and custom fenced-code renderers. */
+type AgentMarkdownOptions = {
+    /**
+     * Animate newly streamed content. Pass `false` to disable text animation.
+     * @default {animation: "blurIn", duration: 160, easing: "ease-out", sep: "word", stagger: 18}
+     */
+    animated?: AgentMarkdownAnimation;
+    /** Streaming caret style. Pass `false` to hide it. @default "block" */
+    caret?: AgentMarkdownCaret | false;
+    /** Custom fenced-code renderers. */
+    plugins?: AgentMarkdownPlugins;
+};
+/** Corner that anchors the launcher button and the floating panel. */
+type AgentLauncherPosition = "bottom-left" | "bottom-right";
+/** Placement of the floating launcher button (visibility is `showLauncher`). */
+type AgentLauncherOptions = {
+    /**
+     * Fill of the launcher button. Defaults to the accent color; set it when a
+     * custom {@link icon} needs a different backdrop. The mark inside gets a
+     * contrasting foreground automatically.
+     */
+    background?: AgentThemeColor;
+    /**
+     * Image rendered inside the launcher button instead of the built-in spark
+     * mark. Use a square asset (70x70 or larger); it is scaled to fit.
+     */
+    icon?: string;
+    /**
+     * Pixel offsets from the anchored corner: `x` from the side edge, `y` from
+     * the bottom. Defaults to 24 (16 on small screens).
+     */
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+    /** @default "bottom-right" */
+    position?: AgentLauncherPosition;
+    /**
+     * Escape hatch for launcher styling the options above do not cover, applied
+     * as inline styles on the button (so it wins over the stylesheet). Prefer the
+     * dedicated options where they exist; this is not covered by the embed's
+     * visual defaults and can break the button's layout.
+     */
+    style?: CSSProperties;
+};
+/** Optional hosted-agent capabilities, all off by default. */
+type AgentCapabilities = {
+    /**
+     * Allow the hosted agent to search for images via web search. Only applies
+     * when {@link webSearch} is enabled; defaults to true in that case.
+     * @default true
+     */
+    imageSearch?: boolean;
+    /**
+     * Allow the hosted agent to search the public web for current information
+     * and images. Results are untrusted external content; keep this off when the
+     * assistant should only ever answer from your declared client tools.
+     * @default false
+     */
+    webSearch?: boolean;
+};
+/** Browser client-tool approval policy. */
+type AgentPermissionOptions = {
+    /**
+     * Permission mode used before an end user chooses another mode.
+     * `"ask"` gates every client tool, `"auto"` gates only tools marked
+     * `needsApproval`, and `"full"` runs client tools without prompting.
+     * @default "auto"
+     */
+    defaultMode?: AgentPermissionMode;
+    /**
+     * Show the permission picker in the composer, letting the end user switch
+     * modes for themselves.
+     *
+     * This is a privilege boundary, not just a control: it permits the end user
+     * to select `"full"` and run every client tool without approval, overriding
+     * {@link defaultMode}. Their choice persists for the conversation.
+     *
+     * The picker only renders when {@link HeroUIAgentProps.tools} is non-empty,
+     * since there is nothing to approve otherwise.
+     * @default false
+     */
+    showPicker?: boolean;
+};
+/**
+ * Size and expansion of the chat panel. In `floating` mode expansion grows the
+ * card; in `sidebar` mode it temporarily fills the viewport. Initial dimensions
+ * are ignored in `sidebar` mode and below the mobile breakpoint.
+ */
+type AgentPanelOptions = {
+    /**
+     * Open the panel expanded. End users can still collapse it unless
+     * {@link expandable} is off.
+     * @default false
+     */
+    expanded?: boolean;
+    /**
+     * Offer the expand control in the panel header. In sidebar mode the expanded
+     * panel fills the viewport. Turn it off to pin the panel to one size.
+     * @default true
+     */
+    expandable?: boolean;
+    /**
+     * Panel height before expanding — a number in pixels or any CSS length.
+     * Capped to the viewport.
+     * @default "max(420px, 56dvh)"
+     */
+    initialHeight?: number | string;
+    /**
+     * Panel width before expanding — a number in pixels or any CSS length.
+     * Expanding widens the panel from here. Capped to the viewport.
+     * @default 440
+     */
+    initialWidth?: number | string;
+};
+/** Visual presentation: view mode, theme, panel size, and launcher placement. */
+type AgentAppearance = {
+    /** Where the launcher button (and the floating panel) is anchored. */
+    launcher?: AgentLauncherOptions;
+    /** Size and expansion of the floating panel. */
+    panel?: AgentPanelOptions;
+    theme?: AgentThemeOptions;
+    /**
+     * How the chat opens: `"floating"` (default) is a floating rounded panel in
+     * the corner; `"sidebar"` docks full-height to the right edge of the page.
+     */
+    viewMode?: AgentViewMode;
+};
+/** Message composer settings. */
+type AgentComposerOptions = {
+    /**
+     * File types end users can attach. Omit to allow every supported type, pass
+     * a subset to narrow the picker, or pass `false` to remove attachments.
+     * @default all supported attachment types
+     */
+    attachments?: AgentAttachmentContentType[] | false;
+    /**
+     * Model used for new turns before an end user chooses another model.
+     * When the picker is disabled, this pins every turn to the configured model.
+     */
+    defaultModel?: AgentModelId;
+    /** Show microphone recording and voice transcription controls. @default true */
+    dictation?: boolean;
+    /**
+     * Small verification notice shown below the composer and above the HeroUI
+     * attribution. Supports `[label](example.com)` and HTTPS links; bare domains
+     * are normalized to HTTPS. Limited to 240 characters. Pass `false` or omit it
+     * to hide the notice.
+     * @default false
+     * @example "Agent may make mistakes. [View terms](https://example.com/terms)"
+     */
+    disclaimer?: string | false;
+    /** Let the end user choose from the hosted agent's allowlisted models. @default false */
+    modelPicker?: boolean;
+    /** Placeholder shown in the message composer. @default "Ask anything…" */
+    placeholder?: string;
+};
+/** The empty-conversation view shown before the first message. */
+type AgentStartScreenOptions = {
+    /** Heading shown above the composer. @default "Ask about your data" */
+    greeting?: string;
+    /** Show and enable `Ctrl+1`…`Ctrl+5` shortcuts for the visible prompts. @default false */
+    promptShortcuts?: boolean;
+    /** Up to five suggested prompts (each max 160 characters). */
+    prompts?: string[];
+};
+/** Internal — for HeroUI platform development only. */
+type AgentApiOverrides = {
+    baseUrl?: string;
+    realtimeUrl?: string;
+};
+/**
+ * Short-lived browser credential returned by the customer's server.
+ *
+ * Declared here rather than re-exported from `@heroui/agent-client`: that
+ * package is bundled into this one, so a re-export would leave a dangling
+ * reference in the published typings. The two declarations are structurally
+ * identical, which is what lets the session manager accept this callback.
+ */
+type AgentAuthToken = {
+    expiresAt: number;
+    token: string;
+};
+/** Context supplied whenever the SDK needs a fresh browser credential. */
+type GetAuthTokenContext = {
+    anonymousId: string;
+    agentId: string;
+};
+type GetAuthToken = (context: GetAuthTokenContext) => Promise<AgentAuthToken>;
+type HeroUIAgentProps = {
+    /** Internal — for HeroUI platform development only. */
+    _api?: AgentApiOverrides;
+    appearance?: AgentAppearance;
+    capabilities?: AgentCapabilities;
+    /** Component export formats to show. Pass `false` to hide export and copy controls. */
+    componentExports?: AgentComponentExportFormat[] | false;
+    composer?: AgentComposerOptions;
+    /**
+     * Shared context for client tools; its reserved `page` key supplies the
+     * page context sent to the agent. See {@link AgentSharedContext}.
+     */
+    context?: AgentSharedContext;
+    /**
+     * Fetches a short-lived browser credential from the host application's
+     * server. Never expose a HeroUI Agent API key in browser code.
+     */
+    getAuthToken: GetAuthToken;
+    /** Streaming Markdown animation, caret, and custom fenced-code renderers. */
+    markdown?: AgentMarkdownOptions;
+    /**
+     * Receives end-user ratings for assistant responses. Negative ratings can
+     * include structured reasons and an optional comment from the feedback popover.
+     */
+    onFeedback?: (feedback: AgentResponseFeedback) => Promise<void> | 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.
+     *
+     * 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
+     * choose the moment yourself — `useAgent().preload()` runs the same warm-up
+     * on your signal.
+     * @default true
+     */
+    preload?: boolean;
+    agentId: string;
+    /**
+     * Apply the appearance saved for this project in the HeroUI dashboard —
+     * launcher icon, colors, typography, greeting, and suggested prompts —
+     * without redeploying.
+     *
+     * Anything passed in code wins, field by field, so this only fills in what
+     * you left unset. Pass `false` to ignore the dashboard entirely and
+     * configure the embed exclusively from props.
+     * @default true
+     */
+    remoteConfig?: boolean;
+    /**
+     * Per-message actions shown under assistant responses: `"copy"` copies the
+     * response text, `"feedback"` shows thumbs up/down, `"retry"` regenerates
+     * the last response. Pass `false` to hide all actions.
+     * @default ["copy", "feedback", "retry"]
+     */
+    responseActions?: AgentMessageAction[] | false;
+    /**
+     * Show the floating launcher button when the panel is closed. Set to
+     * `false` when opening the agent exclusively through `useAgent()`.
+     * @default true
+     */
+    showLauncher?: boolean;
+    startScreen?: AgentStartScreenOptions;
+    /**
+     * Client tools the agent can call in the user's browser. Define with
+     * `createToolHelper<Context>()` for typed args and context.
+     */
+    tools?: ClientTool[];
+};
+type AgentController = {
+    hide: () => void;
+    newConversation: () => 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
+     * your own signal: a pricing page, a scroll depth, a form the visitor is
+     * struggling with. Cheap to call repeatedly; the work happens once.
+     */
+    preload: () => void;
+    refreshAuth: () => void;
+    show: () => void;
+    shutdown: () => void;
+    toggle: () => void;
+};
+
+/**
+ * Imperative controls for the embedded agent. Safe to call before
+ * `<HeroUIAgent />` mounts (calls are ignored with a console warning). Pass a
+ * `agentId` when rendering more than one agent on the same page.
+ */
+declare function useAgent(agentId?: string): AgentController;
+/**
+ * One-line agent embed:
+ *
+ * ```tsx
+ * <body>
+ *   {children}
+ *   <HeroUIAgent getAuthToken={getAuthToken} agentId="proj_..." />
+ * </body>
+ * ```
+ *
+ * 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;
+
+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 };

package/dist/index.js

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