@opentiny/tiny-robot-chat 0.5.2-alpha.7 → 0.5.2-alpha.8

package/dist/index.d.ts

@@ -0,0 +1,1038 @@
+import { BubbleListProps } from '@opentiny/tiny-robot';
+import { BubbleProviderProps } from '@opentiny/tiny-robot';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefaultActions } from '@opentiny/tiny-robot';
+import { DefineComponent } from 'vue';
+import { HistoryMenuItem } from '@opentiny/tiny-robot';
+import { HistoryProps } from '@opentiny/tiny-robot';
+import { LayoutFloatingDragDetail } from '@opentiny/tiny-robot';
+import { LayoutFloatingOptions } from '@opentiny/tiny-robot';
+import { LayoutFloatingResizeDetail } from '@opentiny/tiny-robot';
+import { LayoutFloatingState } from '@opentiny/tiny-robot';
+import { MaybeRefOrGetter } from 'vue';
+import { PromptProps } from '@opentiny/tiny-robot';
+import { PromptsProps } from '@opentiny/tiny-robot';
+import { PublicProps } from 'vue';
+import { SenderProps } from '@opentiny/tiny-robot';
+import { ShallowRef } from 'vue';
+import { UseConversationOptions } from '@opentiny/tiny-robot-kit';
+import { UseConversationReturn } from '@opentiny/tiny-robot-kit';
+import { WelcomeProps } from '@opentiny/tiny-robot';
+
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"bubble-event": (payload: ChatBubbleEventPayload) => any;
+"update:floating-state": (value: LayoutFloatingState) => any;
+"floating-drag-start": (detail: LayoutFloatingState) => any;
+"floating-drag": (detail: LayoutFloatingState) => any;
+"floating-drag-end": (detail: LayoutFloatingState) => any;
+"floating-resize-start": (detail: LayoutFloatingResizeDetail) => any;
+"floating-resize": (detail: LayoutFloatingResizeDetail) => any;
+"floating-resize-end": (detail: LayoutFloatingResizeDetail) => any;
+"history-action": (payload: ChatHistoryActionPayload) => any;
+"prompt-click": (payload: ChatPromptClickPayload) => any;
+"bubble-state-change": (payload: ChatBubbleStateChangePayload) => any;
+"left-aside-open-change": (args_0: {
+open: boolean;
+source: "user" | "viewport";
+}) => any;
+"right-aside-open-change": (args_0: {
+open: boolean;
+source: "user" | "viewport";
+}) => any;
+"runtime-action-error": (payload: ChatRuntimeActionErrorPayload) => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+"onBubble-event"?: ((payload: ChatBubbleEventPayload) => any) | undefined;
+"onUpdate:floating-state"?: ((value: LayoutFloatingState) => any) | undefined;
+"onFloating-drag-start"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-drag"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-drag-end"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-resize-start"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onFloating-resize"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onFloating-resize-end"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onHistory-action"?: ((payload: ChatHistoryActionPayload) => any) | undefined;
+"onPrompt-click"?: ((payload: ChatPromptClickPayload) => any) | undefined;
+"onBubble-state-change"?: ((payload: ChatBubbleStateChangePayload) => any) | undefined;
+"onLeft-aside-open-change"?: ((args_0: {
+open: boolean;
+source: "user" | "viewport";
+}) => any) | undefined;
+"onRight-aside-open-change"?: ((args_0: {
+open: boolean;
+source: "user" | "viewport";
+}) => any) | undefined;
+"onRuntime-action-error"?: ((payload: ChatRuntimeActionErrorPayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_2: DefineComponent<ChatUIProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+cancel: () => any;
+submit: (payload: ChatSendPayload) => any;
+clear: () => any;
+"create-conversation": () => any;
+"switch-conversation": (payload: {
+readonly id: string;
+}) => any;
+"rename-conversation": (payload: {
+readonly id: string;
+readonly title: string;
+}) => any;
+"delete-conversation": (payload: {
+readonly id: string;
+}) => any;
+"model-select": (payload: ChatModelSelectPayload) => any;
+"model-feature-change": (payload: ChatModelFeatureChangePayload) => any;
+"mcp-add-server": (payload: ChatMcpAddServerPayload) => any;
+"mcp-remove-server": (payload: ChatMcpRemoveServerPayload) => any;
+"mcp-server-enabled-change": (payload: ChatMcpServerEnabledChangePayload) => any;
+"mcp-tool-enabled-change": (payload: ChatMcpToolEnabledChangePayload) => any;
+"bubble-event": (payload: ChatBubbleEventPayload) => any;
+"update:floating-state": (value: LayoutFloatingState) => any;
+"floating-drag-start": (detail: LayoutFloatingState) => any;
+"floating-drag": (detail: LayoutFloatingState) => any;
+"floating-drag-end": (detail: LayoutFloatingState) => any;
+"floating-resize-start": (detail: LayoutFloatingResizeDetail) => any;
+"floating-resize": (detail: LayoutFloatingResizeDetail) => any;
+"floating-resize-end": (detail: LayoutFloatingResizeDetail) => any;
+"update:inputValue": (value: string) => any;
+"history-action": (payload: ChatHistoryActionPayload) => any;
+"prompt-click": (payload: ChatPromptClickPayload) => any;
+"bubble-state-change": (payload: ChatBubbleStateChangePayload) => any;
+"left-aside-open-change": (payload: ChatAsideOpenChangePayload) => any;
+"right-aside-open-change": (payload: ChatAsideOpenChangePayload) => any;
+}, string, PublicProps, Readonly<ChatUIProps> & Readonly<{
+onCancel?: (() => any) | undefined;
+onSubmit?: ((payload: ChatSendPayload) => any) | undefined;
+onClear?: (() => any) | undefined;
+"onCreate-conversation"?: (() => any) | undefined;
+"onSwitch-conversation"?: ((payload: {
+readonly id: string;
+}) => any) | undefined;
+"onRename-conversation"?: ((payload: {
+readonly id: string;
+readonly title: string;
+}) => any) | undefined;
+"onDelete-conversation"?: ((payload: {
+readonly id: string;
+}) => any) | undefined;
+"onModel-select"?: ((payload: ChatModelSelectPayload) => any) | undefined;
+"onModel-feature-change"?: ((payload: ChatModelFeatureChangePayload) => any) | undefined;
+"onMcp-add-server"?: ((payload: ChatMcpAddServerPayload) => any) | undefined;
+"onMcp-remove-server"?: ((payload: ChatMcpRemoveServerPayload) => any) | undefined;
+"onMcp-server-enabled-change"?: ((payload: ChatMcpServerEnabledChangePayload) => any) | undefined;
+"onMcp-tool-enabled-change"?: ((payload: ChatMcpToolEnabledChangePayload) => any) | undefined;
+"onBubble-event"?: ((payload: ChatBubbleEventPayload) => any) | undefined;
+"onUpdate:floating-state"?: ((value: LayoutFloatingState) => any) | undefined;
+"onFloating-drag-start"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-drag"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-drag-end"?: ((detail: LayoutFloatingState) => any) | undefined;
+"onFloating-resize-start"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onFloating-resize"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onFloating-resize-end"?: ((detail: LayoutFloatingResizeDetail) => any) | undefined;
+"onUpdate:inputValue"?: ((value: string) => any) | undefined;
+"onHistory-action"?: ((payload: ChatHistoryActionPayload) => any) | undefined;
+"onPrompt-click"?: ((payload: ChatPromptClickPayload) => any) | undefined;
+"onBubble-state-change"?: ((payload: ChatBubbleStateChangePayload) => any) | undefined;
+"onLeft-aside-open-change"?: ((payload: ChatAsideOpenChangePayload) => any) | undefined;
+"onRight-aside-open-change"?: ((payload: ChatAsideOpenChangePayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+scrollTarget: HTMLDivElement;
+}, any>;
+
+declare type __VLS_Props = {
+    runtime: ChatRuntime;
+    ui?: ChatUIOptions;
+    title?: string;
+    floatingState?: LayoutFloatingState;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'layout-header'?(_: {
+            title: string;
+            isEmpty: boolean;
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+            createConversation: () => void;
+            isLeftAsideOpen: boolean;
+            openLeftAside: () => void;
+            closeLeftAside: () => void;
+            toggleLeftAside: () => void;
+            openRightAside: () => void;
+            closeRightAside: () => void;
+        }): any;
+        'layout-left-aside'?(_: {
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+            isOpen: boolean;
+            createConversation: () => void;
+            switchConversation: (id: string) => void;
+            renameConversation: (id: string, title: string) => void;
+            deleteConversation: (id: string) => void;
+            openLeftAside: () => void;
+            closeLeftAside: () => void;
+            toggleLeftAside: () => void;
+        }): any;
+        'layout-right-aside'?(_: {}): any;
+        'layout-right-aside-title'?(_: {}): any;
+        'layout-main'?(_: {
+            messages: ChatMessageItem<ChatMessageContent, Record<string, unknown>>[];
+            request: ChatRequestView | undefined;
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+        }): any;
+        'layout-footer'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'composer-before'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'header-notice'?(_: {}): any;
+        'request-error'?(_: {
+            error: {};
+        }): any;
+        'welcome-footer'?(_: {}): any;
+        'prompts-footer'?(_: {}): any;
+        'bubble-prefix'?(_: {}): any;
+        'bubble-suffix'?(_: {}): any;
+        'bubble-after'?(_: {}): any;
+        'bubble-content-footer'?(_: {}): any;
+        'sender-footer'?(_: {}): any;
+        'sender-footer-right'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_2(): {
+    attrs: Partial<{}>;
+    slots: {
+        'layout-left-aside'?(_: {
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+            isOpen: boolean;
+            createConversation: typeof handleCreateConversation;
+            switchConversation: (id: string) => void;
+            renameConversation: (id: string, title: string) => void;
+            deleteConversation: (id: string) => void;
+            openLeftAside: () => void;
+            closeLeftAside: () => void;
+            toggleLeftAside: () => void;
+        }): any;
+        'header-notice'?(_: {}): any;
+        'layout-header'?(_: {
+            title: string;
+            isEmpty: boolean;
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+            createConversation: typeof handleCreateConversation;
+            isLeftAsideOpen: boolean;
+            openLeftAside: () => void;
+            closeLeftAside: () => void;
+            toggleLeftAside: () => void;
+            openRightAside: () => void;
+            closeRightAside: () => void;
+        }): any;
+        'request-error'?(_: {
+            error: {};
+        }): any;
+        'layout-main'?(_: {
+            messages: ChatMessageItem<ChatMessageContent, Record<string, unknown>>[];
+            request: ChatRequestView | undefined;
+            conversation: {
+                items: readonly ChatConversationInfo[];
+                activeId: string | null;
+                title: string;
+            };
+        }): any;
+        'welcome-footer'?(_: {}): any;
+        'prompts-footer'?(_: {}): any;
+        'composer-before'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'composer-before'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'layout-footer'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'layout-footer'?(_: {
+            value: string;
+            loading: boolean;
+            disabled: boolean;
+            submitDisabled: boolean;
+            setInputValue: (value: string) => void;
+            submit: (payload: {
+                text: string;
+                structuredData?: ChatStructuredData;
+            }) => void;
+            cancel: () => void;
+            clear: () => void;
+        }): any;
+        'sender-footer'?(_: {}): any;
+        'sender-footer'?(_: {}): any;
+        'sender-footer-right'?(_: {}): any;
+        'sender-footer-right'?(_: {}): any;
+        'bubble-prefix'?(_: {}): any;
+        'bubble-suffix'?(_: {}): any;
+        'bubble-after'?(_: {}): any;
+        'bubble-content-footer'?(_: {}): any;
+        'layout-right-aside-title'?(_: {}): any;
+        'layout-right-aside'?(_: {}): any;
+    };
+    refs: {
+        scrollTarget: HTMLDivElement;
+    };
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare type __VLS_WithTemplateSlots_2<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+declare const CHAT_BUILT_IN_MODEL_FEATURES: readonly ["thinking", "search"];
+
+declare const CHAT_REASONING_EFFORTS: readonly ["low", "medium", "high", "max"];
+
+declare interface ChatAsideOpenChangePayload {
+    readonly open: boolean;
+    readonly source: 'user' | 'viewport';
+}
+
+export declare interface ChatAsideOptions {
+    readonly mode?: 'dock' | 'drawer';
+    readonly width?: number;
+    readonly collapsedWidth?: number;
+    readonly open?: boolean;
+    readonly defaultOpen?: boolean;
+}
+
+export declare interface ChatBrandOptions {
+    readonly name?: string;
+    readonly logo?: unknown;
+}
+
+export declare type ChatBubbleEventPayload = {
+    readonly name: string;
+    readonly payload?: unknown;
+    readonly messageIndex: number;
+    readonly contentIndex: number;
+};
+
+export declare type ChatBubbleListOptions = Omit<BubbleListProps, 'messages' | 'autoScroll'>;
+
+declare interface ChatBubbleOptions {
+    readonly autoScroll?: boolean;
+    readonly bubbleProvider?: Omit<BubbleProviderProps, 'store'>;
+    readonly bubbleList?: ChatBubbleListOptions;
+}
+
+export declare type ChatBubbleStateChangePayload = {
+    readonly key: string;
+    readonly value: unknown;
+    readonly messageIndex: number;
+    readonly contentIndex: number;
+};
+
+export declare interface ChatBubbleView {
+    readonly messages?: readonly ChatMessageItem[];
+}
+
+export declare type ChatBuiltInModelFeature = (typeof CHAT_BUILT_IN_MODEL_FEATURES)[number];
+
+export declare interface ChatComposerLayoutOptions {
+    readonly welcome?: ChatWelcomeComposerPlacement;
+}
+
+export declare interface ChatComposerRuntime {
+    disabled?: ChatReadable<boolean>;
+    submitDisabled?: ChatReadable<boolean>;
+    model?: ChatModelRuntime;
+    mcp?: ChatMcpRuntime;
+}
+
+export declare interface ChatConversation extends ChatConversationInfo {
+    messages: readonly ChatMessageItem[];
+    requestState: ChatRequestState;
+    processingState?: ChatProcessingState;
+    lastError?: unknown | null;
+}
+
+export declare interface ChatConversationInfo {
+    id: string;
+    title: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+
+export declare interface ChatConversationView {
+    readonly items?: readonly ChatConversationInfo[];
+    readonly activeId?: string | null;
+    readonly title?: string;
+}
+
+export declare type ChatCssSize = string | number;
+
+declare interface ChatHeaderSlotProps {
+    readonly title: string;
+    readonly isEmpty: boolean;
+    readonly conversation: ChatConversationView;
+    readonly createConversation: () => void;
+    readonly isLeftAsideOpen: boolean;
+    readonly openLeftAside: () => void;
+    readonly closeLeftAside: () => void;
+    readonly toggleLeftAside: () => void;
+    readonly openRightAside: () => void;
+    readonly closeRightAside: () => void;
+}
+
+declare interface ChatHistoryActionPayload {
+    readonly action: HistoryMenuItem;
+    readonly conversation: ChatConversationInfo;
+}
+
+export declare type ChatHistoryItem = ChatConversationInfo & {
+    raw: ChatConversationInfo;
+};
+
+export declare type ChatHistoryOptions = Omit<HistoryProps<ChatConversationInfo>, 'data' | 'selected' | 'onItemAction'>;
+
+export declare interface ChatLabels {
+    newConversationTitle: string;
+    createConversation: string;
+    renameConversation: string;
+    deleteConversation: string;
+    expandConversationList: string;
+    collapseConversationList: string;
+    composerPlaceholder: string;
+    composerLoadingPlaceholder: string;
+    selectModel: string;
+    mcp: string;
+    thinkingFeature: string;
+    searchFeature: string;
+    welcomeTitle: string;
+    welcomeDescription: string;
+    rightAsideTitle: string;
+    openRightAside: string;
+    closeRightAside: string;
+}
+
+export declare interface ChatLayoutOptions {
+    readonly composer?: Readonly<ChatComposerLayoutOptions>;
+    readonly surface?: Readonly<ChatSurfaceOptions>;
+    readonly emptyState?: 'start' | 'center';
+    readonly contentMaxWidth?: ChatCssSize;
+    readonly panelPadding?: ChatCssSize;
+    readonly panelGap?: ChatCssSize;
+    readonly leftAside?: false | Readonly<ChatAsideOptions>;
+    readonly rightAside?: false | Readonly<ChatRightAsideOptions>;
+}
+
+declare interface ChatLeftAsideSlotProps {
+    readonly conversation: ChatConversationView;
+    readonly isOpen: boolean;
+    readonly createConversation: () => void;
+    readonly switchConversation: (id: string) => void;
+    readonly renameConversation: (id: string, title: string) => void;
+    readonly deleteConversation: (id: string) => void;
+    readonly openLeftAside: () => void;
+    readonly closeLeftAside: () => void;
+    readonly toggleLeftAside: () => void;
+}
+
+declare interface ChatMainSlotProps {
+    readonly messages: readonly ChatMessageItem[];
+    readonly request?: ChatRequestView;
+    readonly conversation: ChatConversationView;
+}
+
+declare interface ChatMcpAddServerPayload {
+    readonly id: string;
+}
+
+declare type ChatMcpOptions = Record<string, never>;
+
+declare interface ChatMcpRemoveServerPayload {
+    readonly id: string;
+}
+
+export declare interface ChatMcpRunConfig {
+    serverIds: readonly string[];
+    toolIds: Readonly<Record<string, readonly string[]>>;
+}
+
+export declare interface ChatMcpRuntime {
+    servers: ChatReadable<readonly ChatMcpServerInfo[]>;
+    tools: ChatReadable<ChatMcpToolState>;
+    addServer: (id: string) => Promise<void> | void;
+    removeServer: (id: string) => Promise<void> | void;
+    setServerEnabled: (id: string, enabled: boolean) => Promise<void> | void;
+    setToolEnabled: (serverId: string, toolId: string, enabled: boolean) => Promise<void> | void;
+}
+
+export declare interface ChatMcpServerConfig {
+    id: string;
+    name: string;
+    baseUrl: string;
+    installed?: boolean;
+    description?: string;
+    icon?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    validate?: (serverId: string) => void;
+}
+
+declare interface ChatMcpServerEnabledChangePayload {
+    readonly id: string;
+    readonly enabled: boolean;
+}
+
+export declare interface ChatMcpServerInfo {
+    id: string;
+    name: string;
+    description?: string;
+    installed: boolean;
+    enabled: boolean;
+    loading?: boolean;
+    error?: unknown;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+
+export declare type ChatMcpServers = readonly ChatMcpServerConfig[];
+
+export declare interface ChatMcpServerView {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly installed: boolean;
+    readonly enabled: boolean;
+    readonly loading?: boolean;
+    readonly error?: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+declare interface ChatMcpToolDefinition {
+    serverId: string;
+    id: string;
+    name: string;
+    originalName: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+
+declare interface ChatMcpToolEnabledChangePayload {
+    readonly serverId: string;
+    readonly toolId: string;
+    readonly enabled: boolean;
+}
+
+export declare interface ChatMcpToolInfo {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+}
+
+export declare type ChatMcpToolMap = Readonly<Partial<Record<string, readonly ChatMcpToolView[]>>>;
+
+export declare type ChatMcpToolState = Readonly<Partial<Record<string, readonly ChatMcpToolInfo[]>>>;
+
+export declare interface ChatMcpToolView {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly enabled: boolean;
+    readonly loading?: boolean;
+}
+
+export declare interface ChatMcpView {
+    readonly servers?: readonly ChatMcpServerView[];
+    readonly tools?: ChatMcpToolMap;
+}
+
+export declare type ChatMessageContent = string | ChatMessagePart[];
+
+export declare interface ChatMessageItem<T extends ChatMessageContent = ChatMessageContent, S extends Record<string, unknown> = Record<string, unknown>> {
+    role?: string;
+    content?: T;
+    reasoning_content?: string;
+    tool_calls?: ChatToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    id?: string;
+    loading?: boolean;
+    state?: S;
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface ChatMessagePart {
+    type: string;
+    [key: string]: unknown;
+}
+
+declare interface ChatModelFeatureChangePayload {
+    readonly id: ChatBuiltInModelFeature;
+    readonly enabled: boolean;
+}
+
+export declare interface ChatModelOption {
+    id: string;
+    label: string;
+    capabilities?: Readonly<Partial<Record<ChatBuiltInModelFeature, boolean>>>;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+
+declare type ChatModelOptions = Record<string, never>;
+
+export declare interface ChatModelOptionView {
+    readonly id: string;
+    readonly label: string;
+    readonly capabilities?: Readonly<Partial<Record<ChatBuiltInModelFeature, boolean>>>;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+export declare interface ChatModelRuntime {
+    options: ChatReadable<readonly ChatModelOption[]>;
+    selectedId: ChatReadable<string | null>;
+    features: ChatReadable<Readonly<Partial<Record<ChatBuiltInModelFeature, boolean>>>>;
+    reasoning?: ChatReadable<ChatRunConfigReasoning>;
+    select: (id: string | null) => Promise<void> | void;
+    setFeature: (id: ChatBuiltInModelFeature, enabled: boolean) => Promise<void> | void;
+}
+
+declare interface ChatModelSelectPayload {
+    readonly id: string | null;
+}
+
+export declare interface ChatModelView {
+    readonly options?: readonly ChatModelOptionView[];
+    readonly selectedId?: string | null;
+    readonly features?: Readonly<Partial<Record<ChatBuiltInModelFeature, boolean>>>;
+    readonly selecting?: boolean;
+    readonly pendingFeatureIds?: readonly ChatBuiltInModelFeature[];
+}
+
+export declare type ChatProcessingState = 'requesting' | 'completing' | string;
+
+declare interface ChatPromptClickPayload {
+    readonly event: MouseEvent;
+    readonly item: PromptProps;
+}
+
+export declare interface ChatPromptsOptions extends Omit<PromptsProps, 'items'> {
+    readonly items?: PromptProps[];
+}
+
+export declare interface ChatProviderConfig {
+    type: ChatProviderType;
+    label?: string;
+    apiUrl?: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    models: ChatProviderModelConfig[];
+}
+
+export declare interface ChatProviderFeatureBody {
+    enabled?: Record<string, unknown>;
+    disabled?: Record<string, unknown>;
+}
+
+export declare interface ChatProviderModelConfig extends Omit<ChatModelOption, 'metadata'> {
+    featureBody?: Partial<Record<ChatBuiltInModelFeature, ChatProviderFeatureBody>>;
+    reasoning?: ChatProviderReasoningConfig;
+}
+
+export declare interface ChatProviderReasoningConfig {
+    efforts?: readonly ChatReasoningEffort[];
+    defaultEffort?: ChatReasoningEffort;
+    effortParam?: string;
+}
+
+export declare type ChatProviderType = 'openai' | 'deepseek' | 'qwen';
+
+/**
+ * Read-only reactive value used by the ChatRuntime protocol.
+ *
+ * Keep this structural instead of exposing Vue's nominal Ref/ComputedRef
+ * types. Consumers may use a different compatible Vue installation (for
+ * example a workspace package with its own Vue peer), while the protocol only
+ * needs the read-only `.value` contract.
+ */
+export declare interface ChatReadable<T> {
+    readonly value: T;
+}
+
+export declare type ChatReasoningEffort = (typeof CHAT_REASONING_EFFORTS)[number];
+
+export declare type ChatRequestState = 'idle' | 'processing' | 'completed' | 'aborted' | 'error';
+
+declare interface ChatRequestView {
+    readonly state: ChatRequestState;
+    readonly processingState?: ChatProcessingState;
+    readonly error?: unknown;
+}
+
+export declare interface ChatRightAsideOptions extends ChatAsideOptions {
+    readonly showClose?: boolean;
+}
+
+export declare interface ChatRunConfig {
+    modelId?: string;
+    features?: Readonly<Partial<Record<ChatBuiltInModelFeature, boolean>>>;
+    reasoning?: ChatRunConfigReasoning;
+    mcp?: ChatMcpRunConfig;
+}
+
+export declare interface ChatRunConfigReasoning {
+    enabled: boolean;
+    effort?: ChatReasoningEffort;
+}
+
+export declare interface ChatRuntime {
+    conversations: ChatReadable<readonly ChatConversationInfo[]>;
+    activeConversation: ChatReadable<ChatConversation | null>;
+    composer: ChatComposerRuntime;
+    actions: ChatRuntimeActions;
+}
+
+export declare interface ChatRuntimeActionErrorPayload {
+    readonly action: 'send' | 'abort' | 'create-conversation' | 'switch-conversation' | 'rename-conversation' | 'delete-conversation' | 'select-model' | 'set-model-feature' | 'add-mcp-server' | 'remove-mcp-server' | 'set-mcp-server-enabled' | 'set-mcp-tool-enabled';
+    readonly payload?: unknown;
+    readonly error: unknown;
+}
+
+export declare interface ChatRuntimeActions {
+    send: (payload: ChatSendPayload) => Promise<boolean>;
+    abort?: () => Promise<void> | void;
+    createConversation: (payload?: {
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }) => Promise<void> | void;
+    switchConversation: (id: string) => Promise<void> | void;
+    renameConversation: (id: string, title: string) => Promise<void> | void;
+    deleteConversation: (id: string) => Promise<void> | void;
+}
+
+export declare type ChatSenderDefaultActions = Omit<DefaultActions, 'submit'> & {
+    readonly submit?: Omit<SubmitActionConfig, 'disabled'>;
+};
+
+export declare interface ChatSenderOptions extends Omit<SenderProps, 'modelValue' | 'defaultValue' | 'loading' | 'disabled' | 'defaultActions'> {
+    readonly defaultActions?: ChatSenderDefaultActions;
+}
+
+export declare interface ChatSenderSlotProps {
+    readonly value: string;
+    readonly loading: boolean;
+    readonly disabled: boolean;
+    readonly submitDisabled: boolean;
+    readonly setInputValue: (value: string) => void;
+    readonly submit: (payload: {
+        text: string;
+        structuredData?: ChatStructuredData;
+    }) => void;
+    readonly cancel: () => void;
+    readonly clear: () => void;
+}
+
+export declare interface ChatSenderView {
+    readonly loading?: boolean;
+    readonly disabled?: boolean;
+    readonly submitDisabled?: boolean;
+}
+
+export declare interface ChatSendPayload {
+    readonly text: string;
+    readonly structuredData?: ChatStructuredData;
+}
+
+export declare type ChatStructuredData = ChatStructuredDataItem[];
+
+export declare interface ChatStructuredDataItem {
+    type: string;
+    [key: string]: unknown;
+}
+
+export declare interface ChatSurfaceOptions {
+    readonly mode?: 'normal' | 'floating';
+    readonly floatingOptions?: Readonly<LayoutFloatingOptions>;
+}
+
+export declare interface ChatToolCall {
+    id: string;
+    type: 'function' | string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+
+declare type ChatToolCallTool = (serverId: string, toolName: string, args: Record<string, unknown>) => Promise<unknown>;
+
+declare type ChatToolListTools = (serverIds: readonly string[], toolIds: Readonly<Record<string, readonly string[]>>) => Promise<readonly ChatMcpToolDefinition[]>;
+
+export declare interface ChatUIData {
+    readonly conversation?: ChatConversationView;
+    readonly bubble?: ChatBubbleView;
+    readonly sender?: ChatSenderView;
+    readonly model?: ChatModelView;
+    readonly mcp?: ChatMcpView;
+    readonly request?: ChatRequestView;
+}
+
+export declare interface ChatUIEmits {
+    'update:floating-state': [value: LayoutFloatingState];
+    'floating-drag-start': [detail: LayoutFloatingDragDetail];
+    'floating-drag': [detail: LayoutFloatingDragDetail];
+    'floating-drag-end': [detail: LayoutFloatingDragDetail];
+    'floating-resize-start': [detail: LayoutFloatingResizeDetail];
+    'floating-resize': [detail: LayoutFloatingResizeDetail];
+    'floating-resize-end': [detail: LayoutFloatingResizeDetail];
+    'update:inputValue': [value: string];
+    submit: [payload: ChatSendPayload];
+    cancel: [];
+    clear: [];
+    'create-conversation': [];
+    'switch-conversation': [payload: {
+        readonly id: string;
+    }];
+    'rename-conversation': [payload: {
+        readonly id: string;
+        readonly title: string;
+    }];
+    'delete-conversation': [payload: {
+        readonly id: string;
+    }];
+    'history-action': [payload: ChatHistoryActionPayload];
+    'prompt-click': [payload: ChatPromptClickPayload];
+    'bubble-state-change': [payload: ChatBubbleStateChangePayload];
+    'bubble-event': [payload: ChatBubbleEventPayload];
+    'model-select': [payload: ChatModelSelectPayload];
+    'model-feature-change': [payload: ChatModelFeatureChangePayload];
+    'mcp-add-server': [payload: ChatMcpAddServerPayload];
+    'mcp-remove-server': [payload: ChatMcpRemoveServerPayload];
+    'mcp-server-enabled-change': [payload: ChatMcpServerEnabledChangePayload];
+    'mcp-tool-enabled-change': [payload: ChatMcpToolEnabledChangePayload];
+    'left-aside-open-change': [payload: ChatAsideOpenChangePayload];
+    'right-aside-open-change': [payload: ChatAsideOpenChangePayload];
+}
+
+export declare interface ChatUIOptions {
+    layout?: Readonly<ChatLayoutOptions>;
+    brand?: Readonly<ChatBrandOptions>;
+    labels?: Readonly<Partial<ChatLabels>>;
+    header?: false;
+    history?: false | Readonly<ChatHistoryOptions>;
+    welcome?: false | Readonly<ChatWelcomeOptions>;
+    prompts?: false | Readonly<ChatPromptsOptions>;
+    bubble?: Readonly<ChatBubbleOptions>;
+    sender?: false | Readonly<ChatSenderOptions>;
+    model?: false | Readonly<ChatModelOptions>;
+    mcp?: false | Readonly<ChatMcpOptions>;
+}
+
+export declare interface ChatUIProps {
+    data?: Readonly<ChatUIData>;
+    ui?: Readonly<ChatUIOptions>;
+    inputValue?: string;
+    defaultInputValue?: string;
+    floatingState?: LayoutFloatingState;
+}
+
+export declare interface ChatUISlots {
+    'layout-header'?: (props: ChatHeaderSlotProps) => unknown;
+    'layout-left-aside'?: (props: ChatLeftAsideSlotProps) => unknown;
+    'layout-right-aside'?: () => unknown;
+    'layout-right-aside-title'?: () => unknown;
+    'layout-main'?: (props: ChatMainSlotProps) => unknown;
+    'layout-footer'?: (props: ChatSenderSlotProps) => unknown;
+    'composer-before'?: (props: ChatSenderSlotProps) => unknown;
+    'header-notice'?: () => unknown;
+    'request-error'?: (props: {
+        error: unknown;
+    }) => unknown;
+    'welcome-footer'?: () => unknown;
+    'prompts-footer'?: () => unknown;
+    'bubble-prefix'?: () => unknown;
+    'bubble-suffix'?: () => unknown;
+    'bubble-after'?: () => unknown;
+    'bubble-content-footer'?: () => unknown;
+    'sender-footer'?: () => unknown;
+    'sender-footer-right'?: () => unknown;
+}
+
+export declare type ChatWelcomeComposerPlacement = 'footer' | 'center';
+
+export declare type ChatWelcomeOptions = Partial<WelcomeProps>;
+
+/** Writable counterpart used only where an adapter must mirror state out. */
+export declare interface ChatWritable<T> {
+    value: T;
+}
+
+declare function handleCreateConversation(): void;
+
+declare interface KitRuntimeSendPayload extends ChatSendPayload {
+    runConfig?: ChatRunConfig;
+}
+
+export { LayoutFloatingDragDetail }
+
+export { LayoutFloatingOptions }
+
+export { LayoutFloatingResizeDetail }
+
+export { LayoutFloatingState }
+
+declare type SubmitActionConfig = NonNullable<DefaultActions['submit']>;
+
+declare type TitleGenerator = (text: string) => string;
+
+export declare const TrChat: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const TrChatUI: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
+
+export declare function useChatHistoryItems(options: UseChatHistoryItemsOptions): Readonly<ShallowRef<readonly ChatHistoryItem[]>>;
+
+export declare interface UseChatHistoryItemsOptions {
+    conversations: MaybeRefOrGetter<readonly ChatConversationInfo[] | undefined>;
+    defaultTitle: MaybeRefOrGetter<string>;
+}
+
+export declare function useChatRuntimeAdapter(options: UseChatRuntimeAdapterOptions): {
+    data: ComputedRef<ChatUIData>;
+    inputValue: ChatReadable<string>;
+    setInputValue: (value: string) => void;
+    send: (payload: ChatSendPayload) => boolean | Promise<boolean>;
+    abort: () => Promise<void | undefined>;
+    createConversation: () => Promise<void | undefined>;
+    switchConversation: (id: string) => Promise<void | undefined>;
+    renameConversation: (id: string, title: string) => Promise<void | undefined>;
+    deleteConversation: (id: string) => Promise<void | undefined>;
+    selectModel: (id: string | null) => Promise<void>;
+    setModelFeature: (id: ChatBuiltInModelFeature, enabled: boolean) => Promise<void>;
+    addMcpServer: (id: string) => Promise<void>;
+    removeMcpServer: (id: string) => Promise<void>;
+    setMcpServerEnabled: (id: string, enabled: boolean) => Promise<void>;
+    setMcpToolEnabled: (serverId: string, toolId: string, enabled: boolean) => Promise<void>;
+};
+
+export declare interface UseChatRuntimeAdapterOptions {
+    runtime: MaybeRefOrGetter<ChatRuntime>;
+    title?: MaybeRefOrGetter<string | undefined>;
+    onActionError: (payload: ChatRuntimeActionErrorPayload) => void;
+}
+
+declare type UseKitChatComposerOptions = ChatRuntime['composer'];
+
+export declare function useKitChatRuntime(options: UseKitChatRuntimeOptions): ChatRuntime;
+
+export declare interface UseKitChatRuntimeOptions {
+    conversation: UseConversationReturn;
+    lastError?: ChatWritable<unknown | null>;
+    titleGenerator?: TitleGenerator;
+    send?: (payload: KitRuntimeSendPayload) => Promise<void> | void;
+    composer?: UseKitChatComposerOptions;
+}
+
+export declare function useLocalChatRuntime(options: UseLocalChatRuntimeOptions): ChatRuntime;
+
+export declare interface UseLocalChatRuntimeMcpAdapter {
+    runtime: ChatMcpRuntime;
+    listTools: ChatToolListTools;
+    callTool: ChatToolCallTool;
+}
+
+export declare interface UseLocalChatRuntimeOptions {
+    conversation?: Omit<UseConversationOptions, 'useMessageOptions'> & {
+        useMessageOptions?: Partial<UseConversationOptions['useMessageOptions']>;
+    };
+    titleGenerator?: (text: string) => string;
+    composer?: Pick<ChatComposerRuntime, 'disabled' | 'submitDisabled'>;
+    modelProviders?: readonly ChatProviderConfig[];
+    mcp?: UseLocalChatRuntimeMcpAdapter;
+    mcpServers?: ChatMcpServers;
+}
+
+export { }