@opentiny/tiny-robot 0.4.2-alpha.3 → 0.4.2-alpha.5

package/dist/bubble/BubbleBoxWrapper.vue.d.ts

@@ -0,0 +1,22 @@
+import { BubbleMessage, BubbleProps } from './index.type';
+type __VLS_Props = Pick<BubbleProps, 'role' | 'placement' | 'shape'> & {
+    messages: BubbleMessage[];
+    contentIndex?: number;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/bubble/BubbleContentWrapper.vue.d.ts

@@ -0,0 +1,16 @@
+import { BubbleContentRendererProps } from './index.type';
+type __VLS_Props = BubbleContentRendererProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "state-change": (payload: {
+        key: string;
+        value: unknown;
+        contentIndex: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onState-change"?: ((payload: {
+        key: string;
+        value: unknown;
+        contentIndex: number;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/bubble/BubbleItem.vue.d.ts

@@ -0,0 +1,36 @@
+import { BubbleMessageGroup, BubbleProps, BubbleRoleConfig, BubbleSlots } from './index.type';
+type __VLS_Props = {
+    messageGroup: BubbleMessageGroup;
+    roleConfig?: BubbleRoleConfig;
+    contentRenderMode?: BubbleProps['contentRenderMode'];
+    contentResolver?: BubbleProps['contentResolver'];
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<BubbleSlots> & BubbleSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "state-change": (payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onState-change"?: ((payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/bubble/BubbleList.vue.d.ts

@@ -0,0 +1,41 @@
+import { BubbleListProps, BubbleListSlots, BubbleMessage, BubbleMessageGroup } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<BubbleListSlots> & BubbleListSlots;
+    refs: {
+        listRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BubbleListProps, {
+    scrollToBottom: (behavior?: ScrollBehavior) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "state-change": (payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<BubbleListProps> & Readonly<{
+    "onState-change"?: ((payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any) | undefined;
+}>, {
+    contentResolver: (message: BubbleMessage) => import('./index.type').ChatMessageContent | undefined;
+    groupStrategy: "consecutive" | "divider" | ((messages: BubbleMessage[], dividerRole?: string) => BubbleMessageGroup[]);
+    dividerRole: string;
+    fallbackRole: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    listRef: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/bubble/BubbleProvider.vue.d.ts

@@ -0,0 +1,18 @@
+import { BubbleProviderProps } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BubbleProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BubbleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/bubble/composables/index.d.ts

@@ -0,0 +1,10 @@
+export * from './useBubbleBoxRenderer';
+export * from './useBubbleContentRenderer';
+export * from './useBubbleStateChange';
+export * from './useBubbleStore';
+export * from './useContentResolver';
+export * from './useCopyCleanup';
+export * from './useMessageContent';
+export * from './useMessageGroup';
+export * from './useOmitMessageFields';
+export * from './useToolCall';

package/dist/bubble/composables/useBubbleBoxRenderer.d.ts

@@ -0,0 +1,18 @@
+import { Component, ComputedRef, MaybeRefOrGetter } from 'vue';
+import { BubbleAttributes, BubbleBoxAttributesConfig, BubbleBoxRendererMatch, BubbleMessage } from '../index.type';
+export declare function setupBubbleBoxRenderer(renderers: {
+    boxRendererMatches?: MaybeRefOrGetter<Array<BubbleBoxRendererMatch>>;
+    boxAttributes?: MaybeRefOrGetter<BubbleBoxAttributesConfig | undefined>;
+    fallbackBoxRenderer?: MaybeRefOrGetter<Component>;
+}): void;
+/**
+ * Setup prop-level fallback box renderer
+ * Used in Bubble component to provide prop-level configuration that won't override parent provider
+ */
+export declare function setupBubblePropBoxRenderer(renderers: {
+    fallbackBoxRenderer?: MaybeRefOrGetter<Component | undefined>;
+}): void;
+export declare function useBubbleBoxRenderer(messages: MaybeRefOrGetter<BubbleMessage[]>, contentIndex?: number): ComputedRef<{
+    renderer: Component;
+    attributes?: BubbleAttributes;
+}>;

package/dist/bubble/composables/useBubbleContentRenderer.d.ts

@@ -0,0 +1,18 @@
+import { Component, ComputedRef, MaybeRefOrGetter } from 'vue';
+import { BubbleAttributes, BubbleContentAttributesConfig, BubbleContentRendererMatch, BubbleMessage } from '../index.type';
+export declare function setupBubbleContentRenderer(renderers: {
+    contentRendererMatches?: MaybeRefOrGetter<Array<BubbleContentRendererMatch>>;
+    contentAttributes?: MaybeRefOrGetter<BubbleContentAttributesConfig | undefined>;
+    fallbackContentRenderer?: MaybeRefOrGetter<Component>;
+}): void;
+/**
+ * Setup prop-level fallback content renderer
+ * Used in Bubble component to provide prop-level configuration that won't override parent provider
+ */
+export declare function setupBubblePropContentRenderer(renderers: {
+    fallbackContentRenderer?: MaybeRefOrGetter<Component | undefined>;
+}): void;
+export declare function useBubbleContentRenderer(message: MaybeRefOrGetter<BubbleMessage>, contentIndex: number): ComputedRef<{
+    renderer: Component;
+    attributes?: BubbleAttributes;
+}>;

package/dist/bubble/composables/useBubbleStateChange.d.ts

@@ -0,0 +1,2 @@
+export declare function setupBubbleStateChangeFn(fn: (key: string, value: unknown) => void): void;
+export declare function useBubbleStateChangeFn(): (key: string, _value: unknown) => void;

package/dist/bubble/composables/useBubbleStore.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Setup bubble store
+ * Call this function in BubbleList or Bubble component to provide a global store
+ * If a store already exists, it will return the existing store without creating a new one
+ *
+ * @param initialData - Initial data for the store (only used if store doesn't exist)
+ * @returns The reactive store object
+ */
+export declare function setupBubbleStore<T extends Record<string, unknown>>(initialData?: T): T;
+/**
+ * Use bubble store
+ * Call this function in child components to access the global store
+ *
+ * @returns The reactive store object, or undefined if not provided
+ */
+export declare function useBubbleStore<T extends Record<string, unknown> = Record<string, unknown>>(): T;

package/dist/bubble/composables/useContentResolver.d.ts

@@ -0,0 +1,5 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BubbleMessage, BubbleProps } from '../index.type';
+type Resolver = BubbleProps['contentResolver'];
+export declare const useContentResolver: (contentResolver?: MaybeRefOrGetter<Resolver>) => (message: BubbleMessage) => import('../index.type').ChatMessageContent | undefined;
+export {};

package/dist/bubble/composables/useCopyCleanup.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+/**
+ * 设置复制事件处理器，清理复制文本中的多余换行
+ * @param elementRef - 需要处理复制事件的元素引用
+ */
+export declare function useCopyCleanup(elementRef: Ref<HTMLElement | null>): void;

package/dist/bubble/composables/useMessageContent.d.ts

@@ -0,0 +1,5 @@
+import { BubbleContentRendererProps, ChatMessageContent, ChatMessageContentItem } from '../index.type';
+export declare const useMessageContent: <T extends ChatMessageContent = ChatMessageContent>(props: Readonly<BubbleContentRendererProps<T>>) => {
+    content: import('vue').ComputedRef<ChatMessageContentItem>;
+    contentText: import('vue').ComputedRef<string>;
+};

package/dist/bubble/composables/useMessageGroup.d.ts

@@ -0,0 +1,4 @@
+import { MaybeRefOrGetter } from 'vue';
+import { BubbleMessageGroup } from '../index.type';
+export declare function setupBubbleMessageGroup(messageGroup: MaybeRefOrGetter<BubbleMessageGroup | undefined>): void;
+export declare function useBubbleMessageGroup(): MaybeRefOrGetter<BubbleMessageGroup | undefined>;

package/dist/bubble/composables/useOmitMessageFields.d.ts

@@ -0,0 +1,12 @@
+import { ComputedRef } from 'vue';
+import { BubbleContentRendererProps, BubbleMessage } from '../index.type';
+/**
+ * Omit specified fields from message and return computed props
+ * @param props - The original props containing the message
+ * @param fields - Array of field names to omit from the message
+ * @returns An object containing restMessage and restProps computed refs
+ */
+export declare function useOmitMessageFields<P extends BubbleContentRendererProps, K extends keyof BubbleMessage>(props: P, fields: K[]): {
+    restMessage: ComputedRef<Omit<BubbleMessage, K>>;
+    restProps: ComputedRef<P>;
+};

package/dist/bubble/composables/useToolCall.d.ts

@@ -0,0 +1,25 @@
+import { BubbleContentRendererProps, ChatMessageContent } from '../index.type';
+declare const toolCallStatus: readonly ["running", "success", "failed", "cancelled"];
+export type ToolCallStatus = (typeof toolCallStatus)[number];
+export declare const useToolCall: (props: BubbleContentRendererProps<ChatMessageContent, {
+    toolCall?: Record<string, {
+        status?: ToolCallStatus;
+        open?: boolean;
+    }>;
+}> & {
+    toolCallIndex: number;
+}) => {
+    toolCall: import('vue').ComputedRef<import('../index.type').ToolCall | undefined>;
+    toolCallWithResult: Readonly<import('vue').Ref<{
+        readonly arguments?: any;
+        readonly result?: any;
+    }, {
+        readonly arguments?: any;
+        readonly result?: any;
+    }>>;
+    state: import('vue').ComputedRef<{
+        status: "success" | "running" | "failed" | "cancelled" | undefined;
+        open: boolean | undefined;
+    }>;
+};
+export {};

package/dist/bubble/constants.d.ts

@@ -0,0 +1,42 @@
+import { Component, InjectionKey, MaybeRefOrGetter } from 'vue';
+import { BubbleBoxAttributesConfig, BubbleBoxRendererMatch, BubbleContentAttributesConfig, BubbleContentRendererMatch, BubbleMessageGroup } from './index.type';
+/**
+ * Injection key for bubble message group
+ * Used to provide/inject message group between BubbleItem and Bubble components
+ */
+export declare const BUBBLE_MESSAGE_GROUP_KEY: InjectionKey<MaybeRefOrGetter<BubbleMessageGroup | undefined>>;
+export declare const BUBBLE_BOX_RENDERER_MATCHES_KEY: InjectionKey<MaybeRefOrGetter<Array<BubbleBoxRendererMatch>>>;
+export declare const BUBBLE_BOX_FALLBACK_RENDERER_KEY: InjectionKey<MaybeRefOrGetter<Component>>;
+export declare const BUBBLE_BOX_ATTRIBUTES_KEY: InjectionKey<MaybeRefOrGetter<BubbleBoxAttributesConfig | undefined>>;
+export declare const BUBBLE_BOX_PROP_FALLBACK_RENDERER_KEY: InjectionKey<MaybeRefOrGetter<Component | undefined>>;
+export declare const BUBBLE_CONTENT_RENDERER_MATCHES_KEY: InjectionKey<MaybeRefOrGetter<Array<BubbleContentRendererMatch>>>;
+export declare const BUBBLE_CONTENT_FALLBACK_RENDERER_KEY: InjectionKey<MaybeRefOrGetter<Component>>;
+export declare const BUBBLE_CONTENT_ATTRIBUTES_KEY: InjectionKey<MaybeRefOrGetter<BubbleContentAttributesConfig | undefined>>;
+export declare const BUBBLE_CONTENT_PROP_FALLBACK_RENDERER_KEY: InjectionKey<MaybeRefOrGetter<Component | undefined>>;
+/**
+ * Injection key for bubble store
+ * Used to provide/inject a global store for sharing data between BubbleList and Bubble components
+ */
+export declare const BUBBLE_STORE_KEY: InjectionKey<Record<string, unknown>>;
+export declare const BUBBLE_STATE_CHANGE_FN_KEY: InjectionKey<(key: string, value: unknown) => void>;
+/**
+ * Bubble list 上下文的注入键
+ * 用于标识 Bubble 组件是否在 BubbleList 下
+ */
+export declare const BUBBLE_LIST_CONTEXT_KEY: InjectionKey<boolean>;
+/**
+ * 气泡渲染器匹配优先级常量
+ *
+ * 用于定义不同类型渲染器的匹配优先级，数值越小优先级越高
+ *
+ * - LOADING: 通常基于 message.loading 判断。比如: `{ loading: true }`
+ * - NORMAL: 普通渲染器的默认优先级
+ * - CONTENT: 通常基于 message.content 判断。比如: `{ content: [{ type: 'image_url', image_url: 'xxx' }] }`
+ * - ROLE: 通常基于 message.role 判断。比如: `{ role: 'tool' }`
+ */
+export declare const BubbleRendererMatchPriority: {
+    readonly LOADING: -1;
+    readonly NORMAL: 0;
+    readonly CONTENT: 10;
+    readonly ROLE: 20;
+};

package/dist/bubble/index.d.ts

@@ -0,0 +1,19 @@
+import { App } from 'vue';
+import { default as BubbleComp } from './Bubble.vue';
+import { default as BubbleListComp } from './BubbleList.vue';
+import { default as BubbleProviderComp } from './BubbleProvider.vue';
+declare const bubbleInstall: (app: App) => void;
+export declare const Bubble: typeof BubbleComp & {
+    install: typeof bubbleInstall;
+};
+declare const bubbleListInstall: (app: App) => void;
+export declare const BubbleList: typeof BubbleListComp & {
+    install: typeof bubbleListInstall;
+};
+declare const bubbleProviderInstall: (app: App) => void;
+export declare const BubbleProvider: typeof BubbleProviderComp & {
+    install: typeof bubbleProviderInstall;
+};
+export { useBubbleBoxRenderer, useBubbleContentRenderer, useBubbleStateChangeFn, useMessageContent, useOmitMessageFields, useToolCall, } from './composables';
+export { BubbleRendererMatchPriority } from './constants';
+export { BubbleRenderers } from './renderers/allRenderers';

package/dist/bubble/index.type.d.ts

@@ -0,0 +1,171 @@
+import { Component, VNode } from 'vue';
+/**
+ * 工具调用接口（支持 OpenAI 格式）
+ */
+export interface ToolCall {
+    id: string;
+    type: 'function' | string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+    [x: string]: any;
+}
+export type ChatMessageContentItem = {
+    type: string;
+    [key: string]: any;
+};
+export type ChatMessageContent = string | ChatMessageContentItem[];
+/**
+ * 聊天消息接口（支持 OpenAI 格式）
+ */
+interface ChatMessage<T extends ChatMessageContent = ChatMessageContent> {
+    role: string;
+    content?: T;
+    reasoning_content?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+type ChatMessageWithOptionalRole<T extends ChatMessageContent = ChatMessageContent> = Omit<ChatMessage<T>, 'role'> & {
+    role?: string;
+};
+export type BubbleMessage<T extends ChatMessageContent = ChatMessageContent, S extends Record<string, unknown> = Record<string, unknown>> = ChatMessageWithOptionalRole<T> & {
+    id?: string;
+    loading?: boolean;
+    state?: S;
+};
+export type BubbleProps = BubbleMessage & {
+    hidden?: boolean;
+    avatar?: VNode | Component;
+    placement?: 'start' | 'end';
+    shape?: 'corner' | 'rounded' | 'none';
+    contentRenderMode?: 'single' | 'split';
+    contentResolver?: (message: BubbleMessage) => ChatMessageContent | undefined;
+    fallbackBoxRenderer?: Component<BubbleBoxRendererProps>;
+    fallbackContentRenderer?: Component<BubbleContentRendererProps>;
+};
+export type BubbleMessageGroup = {
+    role: string;
+    messages: BubbleMessage[];
+    messageIndexes: number[];
+    startIndex: number;
+};
+export type BubbleAttributes = Record<string, unknown>;
+export type BubbleBoxRendererAttributeMap = BubbleAttributes;
+export type BubbleBoxRendererAttributesResolver = (messages: BubbleMessage[], content: ChatMessageContentItem | undefined, contentIndex: number | undefined) => BubbleBoxRendererAttributeMap | undefined;
+export type BubbleBoxAttributesResolver = (messages: BubbleMessage[], content: ChatMessageContentItem | undefined, contentIndex: number | undefined) => BubbleAttributes | undefined;
+export type BubbleContentAttributesResolver = (message: BubbleMessage, content: ChatMessageContentItem, contentIndex: number) => BubbleAttributes | undefined;
+export type BubbleBoxAttributesConfig = BubbleAttributes | BubbleBoxAttributesResolver;
+export type BubbleContentAttributesConfig = BubbleAttributes | BubbleContentAttributesResolver;
+export type BubbleBoxRendererMatch = {
+    /**
+     * 匹配函数，用于判断是否应该使用此渲染器
+     * @param messages - 消息数组
+     * @param content - 要渲染的内容项。仅在 `split` 模式下（contentIndex 为数字）才会传入；为当前消息（messages[0]）经过 `contentResolver` 解析后的内容；`messages[0].content` 一定是一个数组，`content` 则为对应索引的内容项，即 `messages[0].content[contentIndex]`；当 contentIndex 为 undefined 时，content 也为 undefined
+     * @param contentIndex - 内容索引，用于指定要渲染的内容项。仅在 split 模式下才会传入（为数字），此时 messages 数组长度为 1
+     * @returns 如果匹配则返回 true，否则返回 false
+     */
+    find: (messages: BubbleMessage[], content: ChatMessageContentItem | undefined, contentIndex: number | undefined) => boolean;
+    renderer: Component<BubbleBoxRendererProps>;
+    priority?: number;
+    attributes?: BubbleBoxRendererAttributeMap | BubbleBoxRendererAttributesResolver;
+};
+export type BubbleContentRendererMatch = {
+    /**
+     * 匹配函数，用于判断是否应该使用此渲染器
+     * @param message - 消息对象
+     * @param content - 要渲染的内容项。为当前消息经过 contentResolver 解析并统一化后的内容项：若解析结果为数组，则取对应索引的内容项（由 contentIndex 指定）；若为字符串，则转为 { type: 'text', text: string }。统一化为 ChatMessageContentItem 对象格式
+     * @param contentIndex - 内容索引。由 contentResolver 的解析结果为数组时使用。若 contentResolver 解析结果为字符串，content 会转换为对象，此时 contentIndex 为 0
+     * @returns 如果匹配则返回 true，否则返回 false
+     */
+    find: (message: BubbleMessage, content: ChatMessageContentItem, contentIndex: number) => boolean;
+    renderer: Component<BubbleContentRendererProps>;
+    priority?: number;
+    attributes?: BubbleAttributes;
+};
+export type BubbleBoxRendererProps = Pick<BubbleProps, 'placement' | 'shape'>;
+export type BubbleContentRendererProps<T extends ChatMessageContent = ChatMessageContent, S extends Record<string, unknown> = Record<string, unknown>> = {
+    message: BubbleMessage<T, S>;
+    contentIndex: number;
+};
+type BubbleSlotProps = {
+    messages: BubbleMessage[];
+    role?: string;
+};
+export interface BubbleSlots {
+    prefix?: (slotProps: BubbleSlotProps) => VNode | VNode[];
+    suffix?: (slotProps: BubbleSlotProps) => VNode | VNode[];
+    after?: (slotProps: BubbleSlotProps) => VNode | VNode[];
+    'content-footer'?: (slotProps: BubbleSlotProps & {
+        contentIndex?: number;
+    }) => VNode | VNode[];
+}
+/**
+ * 角色配置
+ * 用于配置不同角色的气泡样式
+ */
+export type BubbleRoleConfig = Pick<BubbleProps, 'avatar' | 'placement' | 'shape' | 'hidden' | 'fallbackBoxRenderer' | 'fallbackContentRenderer'>;
+/**
+ * 自定义分组函数类型
+ */
+type BubbleGroupFunction = (messages: BubbleMessage[], dividerRole?: string) => BubbleMessageGroup[];
+export interface BubbleListProps {
+    messages: BubbleMessage[];
+    /**
+     * 分组策略：
+     * - 'consecutive': 连续相同角色的消息合并为一组
+     * - 'divider': 按分割角色分组（每条分割角色消息单独成组，其他消息在两个分割角色之间合并为一组）
+     * - 自定义函数: (messages, dividerRole) => BubbleMessageGroup[]
+     *
+     * 特殊情况：
+     * - hidden 的消息需要单独分组，连续的 hidden 可以同一组
+     */
+    groupStrategy?: 'consecutive' | 'divider' | BubbleGroupFunction;
+    /**
+     * 'divider' 策略的分割角色
+     * 具有此角色的消息将作为分割线
+     * @default 'user'
+     */
+    dividerRole?: string;
+    /**
+     * 当消息没有角色或角色为空时，使用此角色
+     * @default 'assistant'
+     */
+    fallbackRole?: string;
+    /**
+     * 角色配置（头像、位置、形状）
+     */
+    roleConfigs?: Record<string, BubbleRoleConfig>;
+    contentRenderMode?: BubbleProps['contentRenderMode'];
+    contentResolver?: BubbleProps['contentResolver'];
+    /**
+     * 是否自动滚动到底部。需要满足以下条件：
+     * - BubbleList 是可滚动容器（需要 scrollHeight > clientHeight）
+     * - 滚动容器接近底部
+     *
+     * @default false
+     */
+    autoScroll?: boolean;
+}
+export interface BubbleProviderProps {
+    boxRendererMatches?: BubbleBoxRendererMatch[];
+    contentRendererMatches?: BubbleContentRendererMatch[];
+    boxAttributes?: BubbleBoxAttributesConfig;
+    contentAttributes?: BubbleContentAttributesConfig;
+    fallbackBoxRenderer?: Component<BubbleBoxRendererProps>;
+    fallbackContentRenderer?: Component<BubbleContentRendererProps>;
+    store?: Record<string, unknown>;
+}
+type BubbleListSlotProps = BubbleSlotProps & {
+    messageIndexes: number[];
+};
+export interface BubbleListSlots {
+    prefix?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
+    suffix?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
+    after?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
+    'content-footer'?: (slotProps: BubbleListSlotProps & {
+        contentIndex?: number;
+    }) => VNode | VNode[];
+}
+export {};

package/dist/bubble/renderers/Box.vue.d.ts

@@ -0,0 +1,18 @@
+import { BubbleBoxRendererProps } from '../index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BubbleBoxRendererProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BubbleBoxRendererProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/bubble/renderers/Image.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps, ChatMessageContentItem } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps<ChatMessageContentItem[]>;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLImageElement>;
+export default _default;

package/dist/bubble/renderers/Loading.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/bubble/renderers/Markdown.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/bubble/renderers/Reasoning.vue.d.ts

@@ -0,0 +1,9 @@
+import { BubbleContentRendererProps, ChatMessageContent } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps<ChatMessageContent, {
+    thinking?: boolean;
+    open?: boolean;
+}>;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    detailRef: HTMLParagraphElement;
+}, any>;
+export default _default;

package/dist/bubble/renderers/Text.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/bubble/renderers/Tool.vue.d.ts

@@ -0,0 +1,14 @@
+import { ToolCallStatus } from '../composables';
+import { BubbleContentRendererProps, ChatMessageContent } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps<ChatMessageContent, {
+    toolCall?: Record<string, {
+        status?: ToolCallStatus;
+        open?: boolean;
+    }>;
+}> & {
+    toolCallIndex: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    detailRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/bubble/renderers/ToolRole.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps<string>;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/bubble/renderers/Tools.vue.d.ts

@@ -0,0 +1,4 @@
+import { BubbleContentRendererProps } from '../index.type';
+type __VLS_Props = BubbleContentRendererProps;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;