@lichen-ai/chatkit-types 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,2094 @@
+import { ToolCall } from '@langchain/core/messages/tool';
+import type { Types } from '@a2ui/lit/0.8';
+
+export declare type AccentColor = {
+    primary: string;
+    level: 0 | 1 | 2 | 3;
+};
+
+declare type ActionConfig = {
+    type: string;
+    payload?: Record<string, unknown>;
+};
+
+declare type Alignment = 'start' | 'center' | 'end' | 'baseline' | 'stretch';
+
+/**
+ * strategies to host files before attaching them to messages.
+ */
+/**
+ * Attachment associated with a user message. When passed to `sendUserMessage` or
+ * `setComposerValue`, it must already be uploaded by your server. We do not currently
+ * support attaching raw Files to a message.
+ */
+export declare type Attachment = {
+    type: 'file';
+    /** Server-generated identifier for the uploaded file. */
+    id: string;
+    /** Original filename shown in the UI. */
+    name: string;
+    /** MIME type of the file. */
+    mime_type: string;
+} | {
+    type: 'image';
+    /** Server-generated identifier for the uploaded image. */
+    id: string;
+    /** URL used to render the image preview in the UI. */
+    preview_url: string;
+    /** Original filename shown in the UI. */
+    name: string;
+    /** MIME type of the image. */
+    mime_type: string;
+};
+
+export declare type Badge = {
+    type: 'Badge';
+    key?: string;
+    id?: string;
+    label: string;
+    color?: 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'discovery';
+    variant?: 'solid' | 'soft' | 'outline';
+    size?: 'sm' | 'md' | 'lg';
+    pill?: boolean;
+};
+
+declare type BaseTextProps = {
+    value: string;
+    color?: string | ThemeColor;
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    textAlign?: TextAlign;
+    truncate?: boolean;
+    maxLines?: number;
+};
+
+export declare type BasicRoot = {
+    type: 'Basic';
+    key?: string;
+    id?: string;
+    children: (WidgetComponent | WidgetRoot)[];
+    theme?: 'light' | 'dark';
+    direction?: 'row' | 'col';
+} & Pick<BoxBaseProps, 'gap' | 'padding' | 'align' | 'justify'>;
+
+declare type BlockProps = {
+    height?: number | string;
+    width?: number | string;
+    size?: number | string;
+    minHeight?: number | string;
+    minWidth?: number | string;
+    minSize?: number | string;
+    maxHeight?: number | string;
+    maxWidth?: number | string;
+    maxSize?: number | string;
+    aspectRatio?: number | string;
+    radius?: RadiusValue;
+    margin?: number | string | Spacing;
+};
+
+declare type Border = {
+    size: number;
+    color?: string | ThemeColor;
+    style?: 'solid' | 'dashed' | 'dotted' | 'double' | 'groove' | 'ridge' | 'inset' | 'outset';
+};
+
+declare type Borders = {
+    top?: number | Border;
+    right?: number | Border;
+    bottom?: number | Border;
+    left?: number | Border;
+    x?: number | Border;
+    y?: number | Border;
+};
+
+export declare type Box = {
+    type: 'Box';
+    key?: string;
+    id?: string;
+    direction?: 'row' | 'col';
+} & BoxBaseProps;
+
+declare type BoxBaseProps = {
+    children?: WidgetComponent[];
+    align?: Alignment;
+    justify?: Justification;
+    wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    flex?: number | string;
+    gap?: number | string;
+    padding?: number | string | Spacing;
+    border?: number | Border | Borders;
+    background?: string | ThemeColor;
+} & BlockProps;
+
+export declare type Button = {
+    type: 'Button';
+    key?: string;
+    id?: string;
+    submit?: boolean;
+    label?: string;
+    onClickAction?: ActionConfig;
+    iconStart?: WidgetIcon;
+    iconEnd?: WidgetIcon;
+    style?: 'primary' | 'secondary';
+    iconSize?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    color?: 'primary' | 'secondary' | 'info' | 'discovery' | 'success' | 'caution' | 'warning' | 'danger';
+    variant?: ControlVariant;
+    size?: ControlSize;
+    pill?: boolean;
+    uniform?: boolean;
+    block?: boolean;
+    disabled?: boolean;
+};
+
+export declare type Caption = {
+    type: 'Caption';
+    key?: string;
+    id?: string;
+    size?: CaptionSize;
+} & BaseTextProps;
+
+declare type CaptionSize = 'sm' | 'md' | 'lg';
+
+export declare type Card = {
+    type: 'Card';
+    key?: string;
+    id?: string;
+    asForm?: boolean;
+    children: WidgetComponent[];
+    background?: string | ThemeColor;
+    size?: 'sm' | 'md' | 'lg' | 'full';
+    padding?: number | string | Spacing;
+    status?: WidgetStatus;
+    collapsed?: boolean;
+    confirm?: CardAction;
+    cancel?: CardAction;
+    theme?: 'light' | 'dark';
+};
+
+declare type CardAction = {
+    label: string;
+    action: ActionConfig;
+};
+
+export declare const CHAT_EVENT_TYPE_FOLLOW_UP_CONSUMED: "follow_up_consumed";
+
+/**
+ * Encapsulate multi-agent message events
+ */
+export declare interface ChatEventEnvelope<T = unknown> {
+    type: ChatMessageTypeEnum;
+    event?: ChatMessageEventTypeEnum;
+    tags: string[];
+    data: T;
+}
+
+export declare type ChatKitClientSecretObject = {
+    secret: string;
+    organizationId?: string;
+    xpertId?: string;
+    assistantId?: string;
+};
+
+export declare type ChatKitClientSecretResult = string | ChatKitClientSecretObject;
+
+export declare type ChatKitCodeReference = ChatKitReferenceBase & {
+    type: 'code';
+    path: string;
+    startLine: number;
+    endLine: number;
+    language?: string;
+    taskId?: string;
+};
+
+export declare type ChatKitCommandSource = {
+    type: 'slash_command';
+    name: string;
+    source: 'builtin' | 'host' | 'runtime';
+    executionType: ChatKitSlashCommandExecutionType;
+    kind?: ChatKitSlashCommandKind;
+    workflow?: ChatKitPromptWorkflow;
+};
+
+export declare interface ChatKitElementEventMap {
+    'chatkit.error': CustomEvent<{
+        error: Error;
+    }>;
+    'chatkit.response.start': CustomEvent<void>;
+    'chatkit.response.end': CustomEvent<void>;
+    'chatkit.thread.change': CustomEvent<{
+        threadId: string | null;
+    }>;
+    'chatkit.log': CustomEvent<{
+        name: string;
+        data?: Record<string, unknown>;
+    }>;
+}
+
+/**
+ * DOM events emitted by the `xpertai-chatkit` custom element.
+ */
+export declare type ChatKitEvents = {
+    /** Emitted when the ChatKit frame has loaded. */
+    'chatkit.ready': CustomEvent<void>;
+    /** Emitted when an error occurs. You should log these for monitoring and debugging. */
+    'chatkit.error': CustomEvent<{
+        error: Error;
+    }>;
+    /** Emitted when a fire-and-forget client effect is triggered. */
+    'chatkit.effect': CustomEvent<{
+        name: string;
+        data?: Record<string, unknown>;
+    }>;
+    /** Emitted when the assistant begins sending a response. */
+    'chatkit.response.start': CustomEvent<void>;
+    /** Emitted when the assistant finishes sending a response. */
+    'chatkit.response.end': CustomEvent<void>;
+    /** Emitted when the active thread changes. Use this along with `initialThread` to persist the current thread across page loads or sessions. */
+    'chatkit.thread.change': CustomEvent<{
+        threadId: string | null;
+    }>;
+    /** Emitted when ChatKit starts loading a thread (initial load or selected from history). */
+    'chatkit.thread.load.start': CustomEvent<{
+        threadId: string;
+    }>;
+    /** Emitted when ChatKit finished loading a thread. */
+    'chatkit.thread.load.end': CustomEvent<{
+        threadId: string;
+    }>;
+    /** Diagnostic events that can be used for logging/analytics. */
+    'chatkit.log': CustomEvent<{
+        name: string;
+        data?: Record<string, unknown>;
+    }>;
+};
+
+export declare type ChatKitI18nText = LocalizedText;
+
+export declare type ChatKitImageReference = ChatKitReferenceBase & {
+    type: 'image';
+    fileId?: string;
+    url?: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+};
+
+export declare interface ChatkitMessage {
+    status?: string;
+    content: TMessageItems | string;
+    reasoning?: TMessageContentReasoning[];
+    type: 'user' | 'assistant' | 'system' | 'tool' | 'event';
+    id: string;
+    followUpMode?: FollowUpBehavior;
+    followUpStatus?: 'pending' | 'consumed' | 'canceled';
+    targetExecutionId?: string | null;
+    visibleAt?: string | Date | null;
+}
+
+export declare type ChatKitOptions = {
+    /**
+     * ChatKit iframe URL for web component integrations.
+     */
+    frameUrl?: string;
+    /**
+     * Controls how the ChatKit web component is presented.
+     * - `chat`: render the ChatKit iframe in the host layout.
+     * - `pet`: render only the pet launcher until the user clicks the pet.
+     *
+     * @default "chat"
+     */
+    displayMode?: 'chat' | 'pet';
+    api: CustomApiConfig | HostedApiConfig;
+    /**
+     * Default request values that should be injected into every user message sent
+     * from this ChatKit instance.
+     */
+    request?: ChatKitRequestOptions;
+    /**
+     * Locale override for ChatKit UI. If not provided, the browser's locale
+     * will be used. If the locale is not supported, will fall back to English.
+     *
+     * @default navigator.language
+     */
+    locale?: SupportedLocale;
+    /**
+     * Visual appearance configuration options for ChatKit.
+     * * @default "light"
+     */
+    theme?: ColorScheme | ChatKitTheme;
+    /**
+     * Optional animated pet companion rendered by the ChatKit web component over
+     * the host page viewport.
+     * Passing `true` enables the default built-in pet.
+     *
+     * @default false
+     */
+    pet?: boolean | ChatKitPetOptions;
+    /**
+     * The ID of the thread to show when ChatKit is mounted or opened for the first time.
+     * Passing `null` will show the new thread view.
+     *
+     * @default null
+     */
+    initialThread?: null | string;
+    /**
+     * A map of handlers for the client tools configured on your server. The keys
+     * are the names of the client tools, and the values are functions that
+     * will be called when the client tool is invoked. The object (or promise) returned
+     * from the function will be sent back to the server as the result of the client
+     * tool invocation.
+     */
+    onClientTool?: ({ name, params, id, tool_call_id }: {
+        name: string;
+        params: Record<string, unknown>;
+        id?: string;
+        tool_call_id?: string;
+    }) => Promise<ClientToolMessageInput> | ClientToolMessageInput;
+    /**
+     * Whether to show the header in ChatKit. A configuration object can be
+     * provided to customize the header.
+     */
+    header?: {
+        enabled?: boolean;
+        /**
+         * Configuration for header title display, which defaults to showing thread titles.
+         */
+        title?: {
+            /**
+             * @default true
+             */
+            enabled?: boolean;
+            /**
+             * Static text to show in the header title area. When not provided, the
+             * title of the current thread will be shown instead.
+             */
+            text?: string;
+        };
+        /**
+         * Configuration for an additional custom button on the left side of the header.
+         */
+        leftAction?: {
+            icon: HeaderIcon;
+            onClick: () => void;
+        };
+        /**
+         * Configuration for an additional custom button on the right side of the header.
+         */
+        rightAction?: {
+            icon: HeaderIcon;
+            onClick: () => void;
+        };
+    };
+    history?: {
+        enabled?: boolean;
+        showDelete?: boolean;
+        showRename?: boolean;
+    };
+    startScreen?: {
+        /**
+         * The greeting text in the new thread view.
+         *
+         * @default "What can I help with today?"
+         */
+        greeting?: string;
+        /**
+         * A list of starter prompts to show above the composer input when in the new thread view.
+         */
+        prompts?: StartScreenPrompt[];
+    };
+    threadItemActions?: {
+        /**
+         * Whether or not to show the response feedback buttons (thumbs up / thumbs
+         * down) in the response view. When the user clicks on one of the buttons, the
+         * feedback will be sent to your server where you can handle it.
+         * @default false
+         */
+        feedback?: boolean;
+        /**
+         * Whether or not to show the retry button in the response view.
+         * When the user retries a message, server events will be sent to handle
+         * removing thread items and begin generation.
+         * @default false
+         */
+        retry?: boolean;
+        /**
+         * Whether or not to show the share button in the response view.
+         * When the user clicks on one of the buttons, the "message.share" event
+         * will be emitted with the shared content, item ids, and thread id.
+         * @default false
+         */
+        share?: boolean;
+    };
+    composer?: {
+        /**
+         * The placeholder text to show in the composer input.
+         * @default "Message the AI"
+         */
+        placeholder?: string;
+        attachments?: {
+            /**
+             * Whether file attachments are enabled in the composer.
+             *
+             * @default false
+             */
+            enabled: boolean;
+            /**
+             * The maximum size of an attachment in bytes.
+             *
+             * @default 100 * 1024 * 1024 (100MB)
+             */
+            maxSize?: number;
+            /**
+             * The maximum number of attachments that can be sent in a single message.
+             *
+             * @default 10
+             */
+            maxCount?: number;
+            /**
+             *
+             * The MIME types and extensions that are accepted for file uploads,
+             * similar to [`showOpenFilePicker`]. When not specified, all MIME types
+             * and extensions are accepted.
+             *
+             * [`showOpenFilePicker`]:
+             * https://developer.mozilla.org/en-US/docs/Web/API/Window/showOpenFilePicker#accept
+             */
+            accept?: Record<string, string[]>;
+        };
+        /**
+         * When provided a list of tool options, the user will be able to select a tool
+         * from a menu in the composer.
+         */
+        tools?: ToolOption[];
+        /** A list of models that users can choose from before sending a message. */
+        models?: ModelOption[];
+        /**
+         * Slash commands shown when users type `/` at the start of the composer.
+         * Command names should not include the leading slash.
+         */
+        slashCommands?: ChatKitSlashCommand[];
+    };
+    /**
+     * Disclaimer text to display below the composer. Supports links with markdown formatting.
+     */
+    disclaimer?: {
+        text: string;
+        highContrast?: boolean;
+    };
+    entities?: {
+        /**
+         * Returns a list of entities for the input query.
+         * Powers tag autocomplete within the composer.
+         */
+        onTagSearch?: (query: string) => Promise<Entity[]>;
+        onClick?: (entity: Entity) => void;
+        onRequestPreview?: (entity: Entity) => Promise<{
+            preview: Widgets.BasicRoot | null;
+        }>;
+    };
+    widgets?: {
+        onAction?: (action: {
+            type: string;
+            payload?: Record<string, unknown>;
+        }, widgetItem: {
+            id: string;
+            widget: Widgets.Card | Widgets.ListView;
+        }) => Promise<void>;
+    };
+};
+
+export declare type ChatKitPetAnimationMode = 'loop' | 'once';
+
+export declare type ChatKitPetAnimationName = 'idle' | 'running-right' | 'running-left' | 'waving' | 'jumping' | 'failed' | 'waiting' | 'running' | 'review';
+
+export declare type ChatKitPetBoundsPadding = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+
+export declare type ChatKitPetCharacter = {
+    type: 'sprite-atlas';
+    src: string;
+    atlas?: ChatKitPetSpriteAtlas;
+};
+
+export declare type ChatKitPetFrameAnimation = {
+    row?: number;
+    frames?: number;
+    frameDurations?: readonly number[];
+};
+
+export declare type ChatKitPetOptions = {
+    enabled?: boolean;
+    character?: ChatKitPetCharacter;
+    position?: ChatKitPetPositionOptions;
+    behavior?: 'auto' | 'manual';
+    ariaLabel?: string;
+    imageRendering?: 'auto' | 'pixelated' | 'crisp-edges';
+};
+
+export declare type ChatKitPetPin = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right';
+
+export declare type ChatKitPetPositionOptions = {
+    pin?: ChatKitPetPin | null;
+    draggable?: boolean;
+    scale?: number;
+    persist?: boolean;
+    boundsPadding?: number | Partial<ChatKitPetBoundsPadding>;
+    zIndex?: number;
+};
+
+export declare type ChatKitPetSpriteAtlas = {
+    columns?: number;
+    rows?: number;
+    cellWidth?: number;
+    cellHeight?: number;
+    animations?: Partial<Record<ChatKitPetAnimationName, ChatKitPetFrameAnimation>>;
+};
+
+export declare type ChatKitPromptWorkflow = {
+    type: 'prompt_workflow';
+    name?: string;
+    label?: ChatKitI18nText;
+    description?: ChatKitI18nText;
+    tags?: string[];
+};
+
+export declare type ChatKitQuoteReference = ChatKitReferenceBase & {
+    type: 'quote';
+    messageId?: string;
+    source?: string;
+};
+
+export declare type ChatKitReference = ChatKitCodeReference | ChatKitQuoteReference | ChatKitImageReference;
+
+export declare type ChatKitReferenceBase = {
+    id?: string;
+    label?: string;
+    text: string;
+};
+
+export declare type ChatKitReferenceCompositionMode = 'compose' | 'preserve';
+
+export declare type ChatKitRequestContext = {
+    /**
+     * Request-scoped runtime env overrides.
+     * ChatKit forwards this field to LangGraph as `context.env`.
+     */
+    env?: Record<string, string>;
+    [key: string]: unknown;
+};
+
+export declare type ChatKitRequestOptions<TState = Record<string, unknown>, TContext extends ChatKitRequestContext = ChatKitRequestContext, TConfig extends Record<string, unknown> = Record<string, unknown>> = {
+    /**
+     * Custom graph state merged into every submitted message request.
+     * The active user input is always written into `state.human.input`.
+     */
+    state?: TState;
+    /**
+     * Additional stream context merged into every submitted message request.
+     *
+     * Request-scoped runtime env overrides should be placed in `context.env`.
+     * Extend `TContext` with any other request-scoped context fields you need.
+     */
+    context?: TContext;
+    /**
+     * Additional LangGraph run config merged into every submitted message request.
+     *
+     * This is forwarded to the hosted `runs.stream` request as `config`.
+     * Use this for LangGraph runtime controls such as tags or configurable values,
+     * not request-scoped env overrides.
+     */
+    config?: TConfig;
+};
+
+export declare type ChatKitSlashCommand = {
+    /**
+     * Command name without the leading slash.
+     * Valid names use lowercase letters, digits, hyphens, and underscores.
+     */
+    name: string;
+    label?: ChatKitI18nText;
+    description?: ChatKitI18nText;
+    icon?: string | Record<string, unknown>;
+    category?: string;
+    aliases?: string[];
+    argsHint?: string;
+    availability?: ChatKitSlashCommandAvailability;
+    kind?: ChatKitSlashCommandKind;
+    workflow?: ChatKitPromptWorkflow;
+    action: ChatKitSlashCommandAction;
+    source?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+};
+
+export declare type ChatKitSlashCommandAction = {
+    type: 'insert_text';
+    template: string;
+    runtimeCapabilities?: unknown;
+} | {
+    type: 'insert_invocation';
+    template: string;
+    runtimeCapabilities?: unknown;
+} | {
+    type: 'submit_prompt';
+    template: string;
+    runtimeCapabilities?: unknown;
+} | {
+    type: 'client_action';
+    action: {
+        type: string;
+        payload?: Record<string, unknown>;
+    };
+} | {
+    type: 'select_capability';
+    capability: ChatKitSlashCommandCapability;
+};
+
+export declare type ChatKitSlashCommandAvailability = {
+    disabled?: boolean;
+    reason?: string;
+    [key: string]: unknown;
+};
+
+export declare type ChatKitSlashCommandCapability = {
+    type: 'skill';
+    id: string;
+} | {
+    type: 'plugin';
+    id: string;
+} | {
+    type: 'subAgent';
+    id: string;
+};
+
+export declare type ChatKitSlashCommandExecutionType = 'insert_text' | 'insert_invocation' | 'submit_prompt' | 'client_action' | 'select_capability';
+
+export declare type ChatKitSlashCommandKind = 'command' | 'prompt_workflow';
+
+export declare type ChatKitTheme = {
+    /**
+     * The color scheme to use for the ChatKit UI.
+     * @default "light"
+     */
+    colorScheme?: ColorScheme;
+    /**
+     * Typography
+     */
+    typography?: {
+        /**
+         * Base font size in pixels.
+         * @remarks Allowed range: 14-18
+         */
+        baseSize?: 14 | 15 | 16 | 17 | 18;
+        fontSources?: FontObject[];
+        fontFamily?: string;
+        fontFamilyMono?: string;
+    };
+    /**
+     * Determines the overall roundness of the ChatKit UI
+     */
+    radius?: 'pill' | 'round' | 'soft' | 'sharp';
+    /**
+     * Determines the overall spacing of the ChatKit UI
+     * @default "normal"
+     */
+    density?: 'compact' | 'normal' | 'spacious';
+    /**
+     * Color customization options
+     */
+    color?: {
+        grayscale?: GrayscaleOptions;
+        accent?: AccentColor;
+        surface?: SurfaceColors;
+    };
+};
+
+/**
+ * https://js.langchain.com/docs/how_to/streaming/#event-reference
+ */
+export declare enum ChatMessageEventTypeEnum {
+    ON_CONVERSATION_START = "on_conversation_start",
+    ON_CONVERSATION_END = "on_conversation_end",
+    ON_MESSAGE_START = "on_message_start",
+    ON_MESSAGE_END = "on_message_end",
+    ON_TOOL_START = "on_tool_start",
+    ON_TOOL_END = "on_tool_end",
+    ON_TOOL_ERROR = "on_tool_error",
+    /**
+     * Step message in tool call
+     */
+    ON_TOOL_MESSAGE = "on_tool_message",
+    ON_AGENT_START = "on_agent_start",
+    ON_AGENT_END = "on_agent_end",
+    ON_RETRIEVER_START = "on_retriever_start",
+    ON_RETRIEVER_END = "on_retriever_end",
+    ON_RETRIEVER_ERROR = "on_retriever_error",
+    ON_INTERRUPT = "on_interrupt",
+    ON_ERROR = "on_error",
+    ON_CHAT_EVENT = "on_chat_event",
+    ON_CLIENT_EFFECT = "on_client_effect"
+}
+
+/**
+ * Category of step message: determines the display components of computer use
+ */
+export declare enum ChatMessageStepCategory {
+    /**
+     * List of items: urls, files, etc.
+     */
+    List = "list",
+    /**
+     * Websearch results
+     */
+    WebSearch = "web_search",
+    /**
+     * Files list
+     */
+    Files = "files",
+    /**
+     * View a file
+     */
+    File = "file",
+    /**
+     * Program Execution
+     */
+    Program = "program",
+    /**
+     * Iframe
+     */
+    Iframe = "iframe",
+    Memory = "memory",
+    Tasks = "tasks",
+    /**
+     * Knowledges (knowledge base retriever results)
+     */
+    Knowledges = "knowledges"
+}
+
+export declare enum ChatMessageTypeEnum {
+    MESSAGE = "message",
+    EVENT = "event"
+}
+
+export declare type Checkbox = {
+    type: 'Checkbox';
+    key?: string;
+    id?: string;
+    name: string;
+    label?: string;
+    defaultChecked?: boolean;
+    onChangeAction?: ActionConfig;
+    disabled?: boolean;
+    required?: boolean;
+};
+
+export declare function clampPetPosition(position: PetPosition, size: PetSize, viewport: PetViewport, padding: ChatKitPetBoundsPadding): PetPosition;
+
+export declare type ClientToolInterrupt<TRequest extends ClientToolRequest = ClientToolRequest> = LangGraphInterrupt<TRequest>;
+
+export declare type ClientToolInterruptPayload<TRequest extends ClientToolRequest = ClientToolRequest> = LangGraphInterruptPayload<TRequest>;
+
+export declare type ClientToolInterruptTask<TRequest extends ClientToolRequest = ClientToolRequest> = LangGraphInterruptTask<TRequest>;
+
+export declare interface ClientToolMessageInput {
+    content: unknown;
+    name?: string;
+    tool_call_id?: string;
+    status?: 'success' | 'error';
+    artifact?: unknown;
+}
+
+export declare interface ClientToolRequest {
+    clientToolCalls: ToolCall[];
+}
+
+export declare interface ClientToolResponse {
+    toolMessages: ClientToolMessageInput[];
+}
+
+export declare interface ClientTools {
+}
+
+export declare type Col = {
+    type: 'Col';
+    key?: string;
+    id?: string;
+} & BoxBaseProps;
+
+export declare type ColorScheme = 'light' | 'dark';
+
+declare type ControlSize = '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+
+declare type ControlVariant = 'solid' | 'soft' | 'outline' | 'ghost';
+
+declare type CustomApiConfig = {
+    /**
+     * The URL (relative or absolute) of the ChatKit API. The configured endpoint
+     * must conform to the specification defined in the ChatKit SDK documentation.
+     * The easiest way to get started is by using the ChatKit SDK which will help
+     * you define your integration in a declarative way.
+     */
+    url: string;
+    /**
+     * Custom fetch function to use for API requests. This is useful for
+     * overriding the default fetch behavior, such as adding custom headers or
+     * setting credentials.
+     */
+    fetch?: typeof fetch;
+    /**
+     * The domain key that will be used to verify the registered domain
+     * for the integration.
+     */
+    domainKey: string;
+    /**
+     * How attachments will be uploaded to your server. Required when attachments are enabled.
+     */
+    uploadStrategy?: FileUploadStrategy;
+    /**
+     * The base URL for the XpertAI platform hosted API. Used for accessing xpert agents
+     * and other platform features.
+     */
+    apiUrl: string;
+    xpertId?: string;
+};
+
+export declare type DatePicker = {
+    type: 'DatePicker';
+    key?: string;
+    id?: string;
+    name: string;
+    onChangeAction?: ActionConfig;
+    placeholder?: string;
+    defaultValue?: string;
+    min?: string;
+    max?: string;
+    variant?: ControlVariant;
+    size?: ControlSize;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'center' | 'end';
+    pill?: boolean;
+    block?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+};
+
+export declare const DEFAULT_PET_BOUNDS_PADDING: ChatKitPetBoundsPadding;
+
+export declare const DEFAULT_PET_SIZE: {
+    width: 192;
+    height: 208;
+};
+
+export declare const DEFAULT_PET_SPRITESHEET_URL = "/pets/boba/spritesheet.webp";
+
+export declare const DEFAULT_PET_STORAGE_KEY = "chatkit:pet:position:v1";
+
+export declare type Divider = {
+    type: 'Divider';
+    key?: string;
+    id?: string;
+    color?: string | ThemeColor;
+    size?: number | string;
+    spacing?: number | string;
+    flush?: boolean;
+};
+
+/**
+ * A structured object representing a referenceable item such as a
+ * person, document, or internal business object.
+ */
+export declare type Entity = {
+    /**
+     * Human-readable name shown in tags, sources, previews, etc.
+     * e.g. "Harry Potter", "Claim #A-1023", "Q2 Planning Doc"
+     */
+    title: string;
+    id: string;
+    /**
+     * Optional icon to show when rendering the entity.
+     */
+    icon?: string;
+    /**
+     * Whether the entity is interactive can be clicked or previewed.
+     */
+    interactive?: boolean;
+    /**
+     * Optional human-readable group name to group entities by.
+     * e.g. "People", "Documents"
+     */
+    group?: string;
+    /**
+     * Optional metadata that will be proxied to the server if this entity is part of
+     * a submitted user message (e.g. in tags) or for client entity callbacks (e.g. for
+     * click or preview). This is not directly used in ChatKit.js and can contain
+     * arbitrary metadata.
+     */
+    data?: Record<string, string>;
+};
+
+export declare type EventHandler<K extends keyof ChatKitEvents> = (event: ChatKitEvents[K]) => any;
+
+export declare type FileUploadStrategy = {
+    type: 'two_phase';
+} | {
+    type: 'direct';
+    uploadUrl: string;
+};
+
+export declare type FollowUpBehavior = 'queue' | 'steer';
+
+export declare type FontObject = {
+    family: string;
+    src: string;
+    weight?: string | number;
+    style?: 'normal' | 'italic' | 'oblique';
+    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+    unicodeRange?: string;
+};
+
+export declare type Form = {
+    type: 'Form';
+    key?: string;
+    id?: string;
+    onSubmitAction?: ActionConfig;
+    direction?: 'row' | 'col';
+} & BoxBaseProps;
+
+export declare function getPinnedPetPosition(pin: ChatKitPetPin, size: PetSize, viewport: PetViewport, padding: ChatKitPetBoundsPadding): PetPosition;
+
+export declare type GrayscaleOptions = {
+    hue: number;
+    tint: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    shade?: -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4;
+};
+
+export declare type HeaderIcon = 'sidebar-left' | 'sidebar-right' | 'sidebar-open-left' | 'sidebar-open-right' | 'sidebar-open-left-alt' | 'sidebar-open-right-alt' | 'sidebar-floating-left' | 'sidebar-floating-right' | 'sidebar-floating-open-left' | 'sidebar-floating-open-right' | 'sidebar-collapse-left' | 'sidebar-collapse-right' | 'collapse-left' | 'collapse-right' | 'open-left' | 'open-right' | 'double-chevron-left' | 'double-chevron-right' | 'home' | 'home-alt' | 'back-small' | 'back-large' | 'expand-large' | 'collapse-large' | 'expand-small' | 'collapse-small' | 'star' | 'star-filled' | 'chat-temporary' | 'settings-cog' | 'grid' | 'dots-horizontal' | 'dots-vertical' | 'dots-horizontal-circle' | 'dots-vertical-circle' | 'menu' | 'menu-inverted' | 'hamburger' | 'compose' | 'light-mode' | 'dark-mode' | 'close';
+
+export declare const HITL_DECISION_TYPES: readonly ["approve", "edit", "reject", "respond"];
+
+export declare interface HITLAction {
+    name: string;
+    args: Record<string, unknown>;
+}
+
+export declare interface HITLActionRequest extends HITLAction {
+    description?: string;
+}
+
+export declare interface HITLApproveDecision {
+    type: 'approve';
+}
+
+export declare type HITLDecision = HITLApproveDecision | HITLEditDecision | HITLRejectDecision | HITLRespondDecision;
+
+export declare type HITLDecisionType = (typeof HITL_DECISION_TYPES)[number];
+
+export declare interface HITLEditDecision {
+    type: 'edit';
+    editedAction: HITLAction;
+}
+
+export declare type HITLInterrupt<TRequest extends HITLRequest = HITLRequest> = LangGraphInterrupt<TRequest>;
+
+export declare type HITLInterruptPayload<TRequest extends HITLRequest = HITLRequest> = LangGraphInterruptPayload<TRequest>;
+
+export declare type HITLInterruptTask<TRequest extends HITLRequest = HITLRequest> = LangGraphInterruptTask<TRequest>;
+
+export declare interface HITLRejectDecision {
+    type: 'reject';
+    message?: string;
+}
+
+export declare interface HITLRequest {
+    actionRequests: HITLActionRequest[];
+    reviewConfigs: HITLReviewConfig[];
+}
+
+export declare interface HITLRespondDecision {
+    type: 'respond';
+    message: string;
+}
+
+export declare interface HITLResponse {
+    decisions: HITLDecision[];
+}
+
+export declare interface HITLReviewConfig {
+    actionName: string;
+    allowedDecisions: HITLDecisionType[];
+    argsSchema?: Record<string, unknown>;
+}
+
+declare type HostedApiConfig = {
+    /**
+     * Function to get a client token or refresh if the current token is expired.
+     * Returning an object also allows ChatKit to send the active organization id
+     * as the `organization-id` header on hosted API requests.
+     */
+    getClientSecret: (currentClientSecret: string | null) => Promise<ChatKitClientSecretResult>;
+    /**
+     * The base URL for the XpertAI platform hosted API. Used for accessing xpert agents
+     * and other platform features.
+     */
+    apiUrl: string;
+    xpertId?: string;
+};
+
+export declare type I18nObject = {
+    en_US?: string;
+    en?: string;
+    'en-US'?: string;
+    zh_Hans?: string;
+    zh_CN?: string;
+    zh?: string;
+    'zh-Hans'?: string;
+    'zh-CN'?: string;
+    [locale: string]: string | undefined;
+};
+
+export declare type Icon = {
+    type: 'Icon';
+    key?: string;
+    id?: string;
+    name: WidgetIcon;
+    color?: string | ThemeColor;
+    size?: IconSize;
+};
+
+export declare type IconName = 'agent' | 'analytics' | 'atom' | 'batch' | 'bolt' | 'book-open' | 'book-closed' | 'bug' | 'calendar' | 'chart' | 'circle-question' | 'compass' | 'cube' | 'globe' | 'keys' | 'lab' | 'images' | 'lifesaver' | 'lightbulb' | 'map-pin' | 'name' | 'notebook' | 'notebook-pencil' | 'page-blank' | 'profile' | 'profile-card' | 'search' | 'sparkle' | 'sparkle-double' | 'square-code' | 'square-image' | 'square-text' | 'suitcase' | 'write' | 'write-alt' | 'write-alt2';
+
+declare type IconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+
+declare type Image_2 = {
+    type: 'Image';
+    key?: string;
+    id?: string;
+    src: string;
+    alt?: string;
+    frame?: boolean;
+    fit?: 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
+    position?: 'top left' | 'top' | 'top right' | 'left' | 'center' | 'right' | 'bottom left' | 'bottom' | 'bottom right';
+    flush?: boolean;
+} & BlockProps;
+export { Image_2 as Image }
+
+export declare type ImageDetail = 'auto' | 'low' | 'high';
+
+export declare type Input = {
+    type: 'Input';
+    key?: string;
+    id?: string;
+    name: string;
+    inputType?: 'number' | 'email' | 'text' | 'password' | 'tel' | 'url';
+    defaultValue?: string;
+    required?: boolean;
+    pattern?: string;
+    placeholder?: string;
+    allowAutofillExtensions?: boolean;
+    autoSelect?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    variant?: 'soft' | 'outline';
+    size?: ControlSize;
+    gutterSize?: '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    pill?: boolean;
+};
+
+/**
+ * When an interrupt occurs during task execution, the system generates an InterruptPayload.
+ *
+ * Ordinary tool-call interrupts use `toolCalls`; ChatKit client-tool middleware
+ * uses `clientToolCalls` so the UI can route those calls to the client.
+ * Human-in-the-loop interrupts use `actionRequests` and `reviewConfigs` so
+ * ChatKit can collect reviewer decisions and resume with `{ decisions }`.
+ ```json
+ {
+ "type": "event",
+ "event": "on_interrupt",
+ "data": {
+ "tasks": [
+ {
+ "id": "9c4d2ac5-8808-5b6f-855c-4d48aa3d77a7",
+ "name": "Middleware_wPzR2bIXqE_after_model",
+ "path": ["__pregel_pull", "Middleware_wPzR2bIXqE_after_model"],
+ "interrupts": [
+ {
+ "id": "b42f7887d65e57ed11cf08b8927763db",
+ "value": {
+ "toolCalls": [
+ {
+ "name": "getUserStation",
+ "args": {
+ "input": "Query the site selected by the user"
+ },
+ "id": "call_00_swcaUjIaACXOHHaZyNmQB3Vm",
+ "type": "tool_call"
+ }
+ ]
+ }
+ }
+ ]
+ }
+ ]
+ }
+ }
+ ```
+ */
+export declare interface InterruptPayload extends LangGraphInterruptPayload<InterruptRequest> {
+}
+
+export declare type InterruptRequest = ToolCallRequest | ClientToolRequest | HITLRequest;
+
+export declare function isClientToolInterrupt(value: unknown): value is ClientToolInterrupt;
+
+export declare function isClientToolInterruptPayload(value: unknown): value is ClientToolInterruptPayload;
+
+export declare function isClientToolInterruptTask(value: unknown): value is ClientToolInterruptTask;
+
+export declare function isClientToolRequest(value: unknown): value is ClientToolRequest;
+
+export declare function isHITLDecisionType(value: unknown): value is HITLDecisionType;
+
+export declare function isHITLInterrupt(value: unknown): value is HITLInterrupt;
+
+export declare function isHITLInterruptPayload(value: unknown): value is HITLInterruptPayload;
+
+export declare function isHITLInterruptTask(value: unknown): value is HITLInterruptTask;
+
+export declare function isHITLRequest(value: unknown): value is HITLRequest;
+
+export declare function isInterruptRequest(value: unknown): value is InterruptRequest;
+
+export declare function isLangGraphInterrupt(value: unknown): value is LangGraphInterrupt;
+
+export declare function isLangGraphInterruptPayload(value: unknown): value is LangGraphInterruptPayload;
+
+export declare function isLangGraphInterruptTask(value: unknown): value is LangGraphInterruptTask;
+
+export declare function isToolCallInterrupt(value: unknown): value is ToolCallInterrupt;
+
+export declare function isToolCallInterruptPayload(value: unknown): value is ToolCallInterruptPayload;
+
+export declare function isToolCallInterruptTask(value: unknown): value is ToolCallInterruptTask;
+
+export declare function isToolCallRequest(value: unknown): value is ToolCallRequest;
+
+declare type Justification = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly' | 'stretch';
+
+export declare type Label = {
+    type: 'Label';
+    key?: string;
+    id?: string;
+    value: string;
+    fieldName: string;
+    size?: TextSize;
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    textAlign?: TextAlign;
+    color?: string | ThemeColor;
+};
+
+export declare interface LangGraphInterrupt<TValue = unknown> {
+    id: string;
+    value: TValue;
+    when?: string;
+    resumable?: boolean;
+    ns?: string[];
+}
+
+export declare interface LangGraphInterruptPayload<TValue = unknown> {
+    tasks: Array<LangGraphInterruptTask<TValue>>;
+}
+
+export declare interface LangGraphInterruptTask<TValue = unknown> {
+    id: string;
+    name: string;
+    path: Array<string | number>;
+    interrupts: Array<LangGraphInterrupt<TValue>>;
+}
+
+export declare type ListView = {
+    type: 'ListView';
+    key?: string;
+    id?: string;
+    children: ListViewItem[];
+    limit?: number | 'auto';
+    status?: WidgetStatus;
+    theme?: 'light' | 'dark';
+};
+
+export declare type ListViewItem = {
+    type: 'ListViewItem';
+    key?: string;
+    id?: string;
+    children: WidgetComponent[];
+    onClickAction?: ActionConfig;
+    gap?: number | string;
+    align?: Alignment;
+};
+
+export declare type LocalizedText = string | I18nObject;
+
+export declare type Markdown = {
+    type: 'Markdown';
+    key?: string;
+    id?: string;
+    value: string;
+    streaming?: boolean;
+};
+
+export declare function mergePetSpriteAtlas(override?: ChatKitPetSpriteAtlas): PetSpriteAtlasDefinition;
+
+export declare type MessageContentImageUrl = {
+    type: 'image_url';
+    image_url: string | {
+        url: string;
+        detail?: ImageDetail;
+    };
+};
+
+export declare type MessageContentText = {
+    type: 'text';
+    text: string;
+};
+
+export declare type ModelOption = {
+    /** Identifier used when submitting a message. */
+    id: string;
+    /** Label displayed in the model picker. */
+    label: string;
+    /** Optional helper text shown with the option. */
+    description?: string;
+    /** When true the option is visible but cannot be selected. */
+    disabled?: boolean;
+    /** Determines if the model should be the default selected option. */
+    default?: boolean;
+};
+
+export declare function normalizeBoundsPadding(value?: number | Partial<ChatKitPetBoundsPadding>): ChatKitPetBoundsPadding;
+
+export declare type NormalizedPetOptions = {
+    character: ChatKitPetCharacter;
+    position: Required<Pick<NonNullable<ChatKitPetOptions['position']>, 'draggable' | 'persist' | 'scale' | 'zIndex'>> & Pick<NonNullable<ChatKitPetOptions['position']>, 'pin' | 'boundsPadding'>;
+    behavior: NonNullable<ChatKitPetOptions['behavior']>;
+    ariaLabel: string;
+    imageRendering: NonNullable<ChatKitPetOptions['imageRendering']>;
+};
+
+export declare function normalizeHITLRequest(value: unknown): HITLRequest | null;
+
+export declare function normalizePetOptions(pet: ChatKitOptions['pet'] | null): NormalizedPetOptions | null;
+
+export declare function normalizeRequestLanguage(locale?: string | null): string | undefined;
+
+export declare const PET_ANIMATION_NAMES: readonly ["idle", "running-right", "running-left", "waving", "jumping", "failed", "waiting", "running", "review"];
+
+export declare type PetFrameAnimationDefinition = {
+    row: number;
+    frames: number;
+    frameDurations: readonly number[];
+};
+
+export declare type PetPosition = {
+    x: number;
+    y: number;
+};
+
+export declare type PetSize = {
+    width: number;
+    height: number;
+};
+
+export declare const petSpriteAtlas: {
+    readonly columns: 8;
+    readonly rows: 9;
+    readonly cellWidth: 192;
+    readonly cellHeight: 208;
+    readonly animations: {
+        readonly idle: {
+            readonly row: 0;
+            readonly frames: 6;
+            readonly frameDurations: readonly [280, 110, 110, 140, 140, 320];
+        };
+        readonly 'running-right': {
+            readonly row: 1;
+            readonly frames: 8;
+            readonly frameDurations: readonly [120, 120, 120, 120, 120, 120, 120, 220];
+        };
+        readonly 'running-left': {
+            readonly row: 2;
+            readonly frames: 8;
+            readonly frameDurations: readonly [120, 120, 120, 120, 120, 120, 120, 220];
+        };
+        readonly waving: {
+            readonly row: 3;
+            readonly frames: 4;
+            readonly frameDurations: readonly [140, 140, 140, 280];
+        };
+        readonly jumping: {
+            readonly row: 4;
+            readonly frames: 5;
+            readonly frameDurations: readonly [140, 140, 140, 140, 280];
+        };
+        readonly failed: {
+            readonly row: 5;
+            readonly frames: 8;
+            readonly frameDurations: readonly [140, 140, 140, 140, 140, 140, 140, 240];
+        };
+        readonly waiting: {
+            readonly row: 6;
+            readonly frames: 6;
+            readonly frameDurations: readonly [150, 150, 150, 150, 150, 260];
+        };
+        readonly running: {
+            readonly row: 7;
+            readonly frames: 6;
+            readonly frameDurations: readonly [120, 120, 120, 120, 120, 220];
+        };
+        readonly review: {
+            readonly row: 8;
+            readonly frames: 6;
+            readonly frameDurations: readonly [150, 150, 150, 150, 150, 280];
+        };
+    };
+};
+
+export declare type PetSpriteAtlasDefinition = {
+    columns: number;
+    rows: number;
+    cellWidth: number;
+    cellHeight: number;
+    animations: Record<ChatKitPetAnimationName, PetFrameAnimationDefinition>;
+};
+
+export declare type PetViewport = {
+    width: number;
+    height: number;
+};
+
+export declare type RadioGroup = {
+    type: 'RadioGroup';
+    key?: string;
+    id?: string;
+    name: string;
+    options?: {
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[];
+    ariaLabel?: string;
+    onChangeAction?: ActionConfig;
+    defaultValue?: string;
+    direction?: 'row' | 'col';
+    disabled?: boolean;
+    required?: boolean;
+};
+
+declare type RadiusValue = '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | 'full' | '100%' | 'none';
+
+export declare const REQUEST_USER_INPUT_RESULT_PURPOSE_IMPLEMENTATION_CONFIRMATION = "implementation_confirmation";
+
+export declare const REQUEST_USER_INPUT_RESULT_PURPOSE_PLAN_CLARIFICATION = "plan_clarification";
+
+export declare const REQUEST_USER_INPUT_RESULT_TYPE = "request_user_input_result";
+
+export declare const REQUEST_USER_INPUT_TOOL_NAME = "request_user_input";
+
+export declare interface RequestUserInputAnswer {
+    id: string;
+    question: string;
+    value: string;
+    type: RequestUserInputAnswerType;
+    label?: string;
+    description?: string;
+}
+
+export declare type RequestUserInputAnswerType = 'option' | 'other';
+
+export declare interface RequestUserInputOption {
+    label: string;
+    description: string;
+}
+
+export declare interface RequestUserInputParams {
+    questions: RequestUserInputQuestion[];
+}
+
+export declare interface RequestUserInputQuestion {
+    id: string;
+    header: string;
+    question: string;
+    options: RequestUserInputOption[];
+}
+
+export declare interface RequestUserInputResult {
+    type: RequestUserInputResultType;
+    purpose: RequestUserInputResultPurpose;
+    answers: RequestUserInputAnswer[];
+}
+
+export declare type RequestUserInputResultPurpose = typeof REQUEST_USER_INPUT_RESULT_PURPOSE_PLAN_CLARIFICATION | typeof REQUEST_USER_INPUT_RESULT_PURPOSE_IMPLEMENTATION_CONFIRMATION;
+
+export declare type RequestUserInputResultType = typeof REQUEST_USER_INPUT_RESULT_TYPE;
+
+export declare type RequestUserInputToolArgs = RequestUserInputParams;
+
+export declare type RequestUserInputToolCall = ToolCall & {
+    name: RequestUserInputToolName;
+    args: RequestUserInputToolArgs;
+    id: string;
+    type?: 'tool_call';
+};
+
+export declare type RequestUserInputToolName = typeof REQUEST_USER_INPUT_TOOL_NAME;
+
+export declare type ResolvedPetCharacter = {
+    kind: 'atlas';
+    src: string;
+    atlas: PetSpriteAtlasDefinition;
+};
+
+export declare function resolveLocalizedText(value: unknown, language?: string): string | null;
+
+export declare function resolvePetCharacter(character: ChatKitPetCharacter): ResolvedPetCharacter | null;
+
+export declare type Row = {
+    type: 'Row';
+    key?: string;
+    id?: string;
+} & BoxBaseProps;
+
+export declare type RuntimeCapabilitiesSelection = RuntimeCapabilitiesSelectionSet & {
+    mode: 'allowlist';
+    recommended?: RuntimeCapabilitiesSelectionSet;
+};
+
+export declare type RuntimeCapabilitiesSelectionSet = {
+    skills: {
+        workspaceId?: string;
+        ids: string[];
+    };
+    plugins: {
+        nodeKeys: string[];
+    };
+    subAgents?: {
+        nodeKeys: string[];
+    };
+};
+
+export declare type Select = {
+    type: 'Select';
+    key?: string;
+    id?: string;
+    name: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    onChangeAction?: ActionConfig;
+    placeholder?: string;
+    defaultValue?: string;
+    variant?: ControlVariant;
+    size?: ControlSize;
+    pill?: boolean;
+    block?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+};
+
+export declare type SendUserMessageParams = {
+    text?: string;
+    content?: UserMessageContent[];
+    state?: Record<string, unknown>;
+    reply?: string;
+    attachments?: Attachment[];
+    newThread?: boolean;
+    references?: ChatKitReference[];
+    referenceComposition?: ChatKitReferenceCompositionMode;
+    toolChoice?: ToolChoice;
+    model?: string;
+    planMode?: boolean;
+    runtimeCapabilities?: RuntimeCapabilitiesSelection;
+    trigger?: WorkflowTriggerParams;
+    followUpMode?: 'default' | FollowUpBehavior;
+};
+
+export declare type Spacer = {
+    type: 'Spacer';
+    key?: string;
+    id?: string;
+    minSize?: number | string;
+};
+
+declare type Spacing = {
+    top?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+    left?: number | string;
+    x?: number | string;
+    y?: number | string;
+};
+
+export declare type StartScreenPrompt = {
+    label: string;
+    prompt: string;
+    icon?: IconName;
+};
+
+export declare const STATE_VARIABLE_HUMAN = "human";
+
+/**
+ * All locales that are accepted by ChatKit without falling back to English.
+ * Includes language codes that are resolved by ChatKit to a translated locale.
+ */
+export declare type SupportedLocale = TranslatedLocale | 'bg' | 'bn' | 'bs' | 'ca' | 'cs' | 'da' | 'de' | 'el' | 'es' | 'et' | 'fi' | 'fr' | 'gu' | 'hi' | 'hr' | 'hu' | 'hy' | 'id' | 'is' | 'it' | 'ja' | 'ka' | 'kn' | 'ko' | 'lv' | 'mk' | 'mr' | 'ms' | 'my' | 'nb' | 'nl' | 'pl' | 'pt' | 'ro' | 'ru' | 'sk' | 'sl' | 'so' | 'sq' | 'sr' | 'sv' | 'sw' | 'ta' | 'te' | 'th' | 'tr' | 'uk' | 'vi' | 'zh' | 'zh-Hans' | 'zh-CN' | 'zh-Hant' | 'en';
+
+export declare type SurfaceColors = {
+    background: string;
+    foreground: string;
+};
+
+/**
+ * Data type for chat event message
+ */
+export declare type TChatEventMessage = {
+    type?: string;
+    title?: string;
+    message?: string;
+    status?: 'success' | 'fail' | 'running';
+    created_date?: Date | string;
+    end_date?: Date | string;
+    error?: string;
+};
+
+/**
+ * Step message type, in canvas and ai message.
+ */
+export declare type TChatMessageStep<T = any> = TMessageComponent<TMessageComponentStep<T>>;
+
+export declare type TChatRequest = {
+    /**
+     * The human input, include parameters
+     */
+    input: TChatRequestHuman;
+    /**
+     * Custom graph state
+     */
+    state?: TXpertChatState;
+    agentKey?: string;
+    projectId?: string;
+    conversationId?: string;
+    environmentId?: string;
+    id?: string;
+    executionId?: string;
+    confirm?: boolean;
+    command?: TInterruptCommand;
+    retry?: boolean;
+    followUpMode?: FollowUpBehavior;
+    /**
+     * PRO: Sandbox Environment Id
+     * PRO: @description Sandbox environment ID to force using the specified container.
+     */
+    sandboxEnvironmentId?: string;
+};
+
+/**
+ * Human input message, include parameters and attachments
+ */
+export declare type TChatRequestHuman = {
+    input?: string;
+    files?: Partial<File>[];
+    references?: ChatKitReference[];
+    referenceComposition?: ChatKitReferenceCompositionMode;
+    planMode?: boolean;
+    runtimeCapabilities?: RuntimeCapabilitiesSelection;
+    commandSource?: ChatKitCommandSource;
+    [key: string]: unknown;
+};
+
+/**
+ * Data type for client effect message
+ */
+export declare type TClientEeffectMessage = {
+    name: string;
+    args: Record<string, unknown>;
+    tool_call_id?: string;
+    agentKey?: string;
+    created_date?: Date | string;
+};
+
+declare type TextAlign = 'start' | 'center' | 'end';
+
+export declare type Textarea = {
+    type: 'Textarea';
+    key?: string;
+    id?: string;
+    name: string;
+    defaultValue?: string;
+    required?: boolean;
+    pattern?: string;
+    placeholder?: string;
+    autoSelect?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    variant?: 'soft' | 'outline';
+    size?: ControlSize;
+    gutterSize?: '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    rows?: number;
+    autoResize?: boolean;
+    maxRows?: number;
+    allowAutofillExtensions?: boolean;
+};
+
+export declare type TextComponent = {
+    type: 'Text';
+    key?: string;
+    id?: string;
+    value: string;
+    streaming?: boolean;
+    italic?: boolean;
+    lineThrough?: boolean;
+    width?: number | string;
+    size?: TextSize;
+    minLines?: number;
+    editable?: false | {
+        name: string;
+        autoFocus?: boolean;
+        autoSelect?: boolean;
+        autoComplete?: string;
+        allowAutofillExtensions?: boolean;
+        pattern?: string;
+        placeholder?: string;
+        required?: boolean;
+    };
+} & BaseTextProps;
+
+declare type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+
+export declare type TFollowUpConsumedEvent = TChatEventMessage & {
+    type: typeof CHAT_EVENT_TYPE_FOLLOW_UP_CONSUMED;
+    mode: 'queue' | 'steer';
+    messageIds: string[];
+    clientMessageIds?: string[];
+    executionId?: string | null;
+    visibleAt?: string | null;
+};
+
+declare type ThemeColor = {
+    dark: string;
+    light: string;
+};
+
+/**
+ * Command to resume with streaming after human decision
+ */
+export declare type TInterruptCommand = {
+    resume?: any;
+    update?: any;
+    toolCalls?: ToolCall[];
+    agentKey?: string;
+};
+
+export declare type Title = {
+    type: 'Title';
+    key?: string;
+    id?: string;
+    size?: TitleSize;
+} & BaseTextProps;
+
+declare type TitleSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
+
+/**
+ * Defines the data type of the sub-message of `component` type in the message `content` {@link MessageContentComplex}
+ */
+export declare type TMessageComponent<T extends object = object> = T & {
+    id?: string;
+    category: 'Dashboard' | 'Computer' | 'Tool';
+    type?: string;
+    created_date?: Date | string;
+};
+
+export declare type TMessageComponentIframe = {
+    type: 'iframe';
+    title: string;
+    url?: string;
+    data?: {
+        url?: string;
+    };
+};
+
+export declare type TMessageComponentStep<T = unknown> = {
+    type: ChatMessageStepCategory;
+    toolset: string;
+    toolset_id: string;
+    tool?: string;
+    title: string;
+    message: string;
+    status: 'success' | 'fail' | 'running';
+    created_date: Date | string;
+    end_date: Date | string;
+    error?: string;
+    data?: T;
+    input?: any;
+    output?: unknown;
+    artifact?: any;
+};
+
+export declare type TMessageComponentWidget = TMessageComponent<TMessageComponentWidgetData>;
+
+export declare type TMessageComponentWidgetData = {
+    type: 'Widget';
+    mode?: string;
+    widgets: TMessageComponentWidgetItem[];
+    executionId?: string;
+};
+
+export declare type TMessageComponentWidgetItem = {
+    name: string;
+    /**
+     * Standard A2UI server-to-client messages. New widget messages should use
+     * this flat protocol shape so the UI can build and isolate surfaces at render time.
+     */
+    messages?: Types.ServerToClientMessage[];
+    /**
+     * @deprecated Legacy pre-resolved surface fallback. Prefer `messages`.
+     */
+    config?: Types.Surface;
+    values?: Record<string, unknown>;
+};
+
+/**
+ * Enhance {@link MessageContent} in Langchain.js
+ *
+ * @deprecated use {@link TMessageItems} instead
+ */
+export declare type TMessageContent = string | TMessageContentComplex[];
+
+/**
+ * Enhance {@link MessageContentComplex} in Langchain.js
+ */
+export declare type TMessageContentComplex = (TMessageContentText | TMessageContentReasoning | MessageContentImageUrl | TMessageContentComponent | TMessageContentMemory | (Record<string, unknown> & {
+    type?: 'text' | 'image_url' | string;
+}) | (Record<string, unknown> & {
+    type?: never;
+})) & {
+    id?: string;
+    xpertName?: string;
+    agentKey?: string;
+    executionId?: string;
+    parentExecutionId?: string;
+    runId?: string;
+    created_date?: Date | string;
+};
+
+/**
+ * Similar to {@link MessageContentText} | {@link MessageContentImageUrl}, which together form {@link MessageContentComplex}
+ */
+export declare type TMessageContentComponent<T extends object = object> = {
+    id: string;
+    type: 'component';
+    data: TMessageComponent<T>;
+    xpertName?: string;
+    agentKey?: string;
+    executionId?: string;
+    parentExecutionId?: string;
+    runId?: string;
+};
+
+export declare type TMessageContentMemory = {
+    id?: string;
+    agentKey?: string;
+    type: 'memory';
+    data: any[];
+};
+
+export declare type TMessageContentReasoning = {
+    id?: string;
+    xpertName?: string;
+    agentKey?: string;
+    executionId?: string;
+    parentExecutionId?: string;
+    runId?: string;
+    type: 'reasoning';
+    text: string;
+};
+
+export declare type TMessageContentText = {
+    id?: string;
+    xpertName?: string;
+    agentKey?: string;
+    executionId?: string;
+    parentExecutionId?: string;
+    runId?: string;
+    type: 'text';
+    text: string;
+};
+
+export declare type TMessageContentWidget = TMessageContentComponent<TMessageComponentWidgetData>;
+
+export declare type TMessageItems = TMessageContentComplex[];
+
+export declare type ToolCallInterrupt<TRequest extends ToolCallRequest = ToolCallRequest> = LangGraphInterrupt<TRequest>;
+
+export declare type ToolCallInterruptPayload<TRequest extends ToolCallRequest = ToolCallRequest> = LangGraphInterruptPayload<TRequest>;
+
+export declare type ToolCallInterruptTask<TRequest extends ToolCallRequest = ToolCallRequest> = LangGraphInterruptTask<TRequest>;
+
+export declare interface ToolCallRequest {
+    toolCalls: ToolCall[];
+}
+
+export declare type ToolChoice = unknown;
+
+export declare type ToolOption = {
+    id: string;
+    /** Label displayed in the tool menu */
+    label: string;
+    /** Label displayed in the button when the tool is selected. */
+    shortLabel?: string;
+    /** Placeholder text to show in the composer input when the tool is selected. */
+    placeholderOverride?: string;
+    /**
+     * Icon displayed next to the tool in the menu.
+     */
+    icon: IconName;
+    /**
+     * Whether the tool is pinned to the composer outside of the tool menu.
+     *
+     * @default false
+     */
+    pinned?: boolean;
+};
+
+export declare type Transition = {
+    type: 'Transition';
+    key?: string;
+    id?: string;
+    children: WidgetComponent;
+};
+
+/**
+ * All locales for which there is an actual translation file.
+ */
+export declare type TranslatedLocale = 'am' | 'ar' | 'bg-BG' | 'bn-BD' | 'bs-BA' | 'ca-ES' | 'cs-CZ' | 'da-DK' | 'de-DE' | 'el-GR' | 'es-419' | 'es-ES' | 'et-EE' | 'fi-FI' | 'fr-CA' | 'fr-FR' | 'gu-IN' | 'hi-IN' | 'hr-HR' | 'hu-HU' | 'hy-AM' | 'id-ID' | 'is-IS' | 'it-IT' | 'ja-JP' | 'ka-GE' | 'kk' | 'kn-IN' | 'ko-KR' | 'lt' | 'lv-LV' | 'mk-MK' | 'ml' | 'mn' | 'mr-IN' | 'ms-MY' | 'my-MM' | 'nb-NO' | 'nl-NL' | 'pa' | 'pl-PL' | 'pt-BR' | 'pt-PT' | 'ro-RO' | 'ru-RU' | 'sk-SK' | 'sl-SI' | 'so-SO' | 'sq-AL' | 'sr-RS' | 'sv-SE' | 'sw-TZ' | 'ta-IN' | 'te-IN' | 'th-TH' | 'tl' | 'tr-TR' | 'uk-UA' | 'ur' | 'vi-VN' | 'zh-CN' | 'zh-HK' | 'zh-TW';
+
+export declare type TThreadContextUsageEvent = {
+    type: 'thread_context_usage';
+    threadId: string;
+    runId: string | null;
+    agentKey: string;
+    updatedAt: string;
+    usage: TThreadContextUsageMetrics;
+};
+
+export declare type TThreadContextUsageMetrics = {
+    contextTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    embedTokens?: number;
+    totalPrice?: number;
+    currency?: string | null;
+};
+
+export declare type TXpertChatInterruptPatch = Pick<TInterruptCommand, 'agentKey' | 'toolCalls' | 'update'>;
+
+export declare type TXpertChatResumeDecision = {
+    type: 'confirm' | 'reject';
+    payload?: unknown;
+};
+
+export declare type TXpertChatResumeRequest = {
+    action: 'resume';
+    conversationId: string;
+    target: TXpertChatTarget;
+    decision: TXpertChatResumeDecision;
+    patch?: TXpertChatInterruptPatch;
+    state?: TXpertChatState;
+};
+
+export declare type TXpertChatState = {
+    [STATE_VARIABLE_HUMAN]?: TChatRequestHuman;
+} & Record<string, unknown>;
+
+export declare type TXpertChatTarget = {
+    aiMessageId?: string;
+    executionId?: string;
+};
+
+export declare type UserMessageContent = unknown;
+
+export declare type WidgetComponent = TextComponent | Title | Caption | Badge | Markdown | Box | Row | Col | Divider | Icon | Image_2 | Button | Checkbox | Spacer | Select | DatePicker | Form | Input | Label | RadioGroup | Textarea | Transition;
+
+export declare type WidgetIcon = 'agent' | 'analytics' | 'atom' | 'batch' | 'bolt' | 'book-open' | 'book-closed' | 'book-clock' | 'bug' | 'calendar' | 'chart' | 'check' | 'check-circle' | 'check-circle-filled' | 'chevron-left' | 'chevron-right' | 'circle-question' | 'compass' | 'confetti' | 'cube' | 'desktop' | 'document' | 'dot' | 'dots-horizontal' | 'dots-vertical' | 'empty-circle' | 'external-link' | 'globe' | 'keys' | 'lab' | 'images' | 'info' | 'lifesaver' | 'lightbulb' | 'mail' | 'map-pin' | 'maps' | 'mobile' | 'name' | 'notebook' | 'notebook-pencil' | 'page-blank' | 'phone' | 'play' | 'plus' | 'profile' | 'profile-card' | 'reload' | 'star' | 'star-filled' | 'search' | 'sparkle' | 'sparkle-double' | 'square-code' | 'square-image' | 'square-text' | 'suitcase' | 'settings-slider' | 'user' | 'wreath' | 'write' | 'write-alt' | 'write-alt2';
+
+export declare type WidgetRoot = Card | ListView | BasicRoot;
+
+declare namespace Widgets {
+    export {
+        WidgetRoot,
+        WidgetComponent,
+        BasicRoot,
+        Card,
+        ListView,
+        ListViewItem,
+        Box,
+        Row,
+        Col,
+        Form,
+        Spacer,
+        Divider,
+        Transition,
+        Title,
+        Caption,
+        TextComponent,
+        Markdown,
+        Badge,
+        Icon,
+        Image_2 as Image,
+        Button,
+        Input,
+        Textarea,
+        Select,
+        DatePicker,
+        Checkbox,
+        RadioGroup,
+        Label,
+        WidgetIcon
+    }
+}
+
+declare type WidgetStatus = {
+    text: string;
+    favicon?: string;
+    frame?: boolean;
+} | {
+    text: string;
+    icon?: WidgetIcon;
+};
+
+export declare type WorkflowTriggerParams = {
+    name?: string;
+    params?: Record<string, unknown>;
+} | Record<string, unknown>;
+
+/**
+ * A Web Component that serves as the entry point for a ChatKit integration.
+ * * @noInheritDoc
+ */
+export declare interface XpertAIChatKit extends HTMLElement {
+    /**
+     * Applies configuration options to the ChatKit instance.
+     *
+     * **IMPORTANT**: New options are not merged with the existing options. You must provide a full set of options every time you call this method.
+     */
+    setOptions(options: ChatKitOptions): void;
+    /** Focuses the composer input field. */
+    focusComposer(): Promise<void>;
+    /** Changes the active thread. Pass `null` to switch to a new thread. */
+    setThreadId(threadId: string | null): Promise<void>;
+    /**
+     * Sends a custom application-defined action to your backend.
+     */
+    sendCustomAction(action: {
+        type: string;
+        payload?: Record<string, unknown>;
+    }, 
+    /**
+     * The ID of the WidgetItem that the action is associated with. You may
+     * need this if the action was triggered by a widget, gets handled
+     * client-side, and then you want to send the action back to the server to
+     * do additional handling.
+     *
+     * @example
+     * ```ts
+     * chatKit.options = {
+     *   // other options...
+     *   widgets: {
+     *     async onAction(action, widgetItem) {
+     *       await someClientSideHandling(action)
+     *       await chatkit.sendAction(action, widgetItem.id)
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    itemId?: string): Promise<void>;
+    /** Sends a user message. */
+    sendUserMessage(params: SendUserMessageParams): Promise<void>;
+    /** Sets the composer's content without sending a message. */
+    setComposerValue(params: {
+        text?: string;
+        reply?: string;
+        attachments?: Attachment[];
+        references?: ChatKitReference[];
+        appendReferences?: boolean;
+        selectedToolId?: string | null;
+        selectedModelId?: string | null;
+    }): Promise<void>;
+    /**
+     * Manually fetches updates from the server.
+     *
+     * Use this when you've manually updated the thread or thread items and need to sync them with the client.
+     */
+    fetchUpdates(): Promise<void>;
+    /**
+     * Adds an event listener for the specified {@link ChatKitEvents} event.
+     *
+     * @example
+     * ```ts
+     * chatKit.addEventListener('chatkit.error', (event) => {
+     *   logToMyErrorLogger(event.detail.error);
+     * });
+     * ```
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener}
+     */
+    addEventListener<K extends keyof ChatKitEvents>(
+    /**
+     * See {@link ChatKitEvents} for available events.
+     */
+    type: K, 
+    /**
+     * The event listener callback.
+     */
+    listener: EventHandler<K>, 
+    /**
+     * An object that specifies characteristics about the event listener.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#options}
+     */
+    options?: boolean | AddEventListenerOptions): void;
+    /* Excluded from this release type: addEventListener */
+    /**
+     * Removes an event listener for the specified event.
+     *
+     * @example
+     * ```ts
+     * chatKit.removeEventListener('chatkit.error', myErrorListener);
+     * ```
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener}
+     */
+    removeEventListener<K extends keyof ChatKitEvents>(
+    /**
+     * See {@link ChatKitEvents} for available events.
+     */
+    type: K, 
+    /**
+     * The event listener callback to remove.
+     */
+    listener: EventHandler<K>, 
+    /**
+     * An object that specifies characteristics about the event listener.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener#options}
+     */
+    options?: boolean | EventListenerOptions): void;
+    /* Excluded from this release type: removeEventListener */
+}
+
+export { }