@opentiny/tiny-robot 0.4.2-alpha.4 → 0.4.2-alpha.6

package/dist/attachments/composables/useFileCard.d.ts

@@ -0,0 +1,15 @@
+import { ActionButton, FileCardProps, FileCardEmits } from '../index.type';
+/**
+ * 管理文件卡片交互逻辑
+ * @param props 组件属性
+ * @param emit 组件事件触发器
+ * @returns 交互处理器
+ */
+export declare function useFileCard(props: FileCardProps, emit: FileCardEmits): {
+    isImage: import('vue').ComputedRef<boolean>;
+    handlePreview: (event: MouseEvent) => void;
+    downloadFile: (event: MouseEvent) => void;
+    handleRemove: () => void;
+    handleRetry: () => void;
+    handleCustomAction: (action: ActionButton, event: MouseEvent) => void;
+};

package/dist/attachments/composables/useFileType.d.ts

@@ -0,0 +1,20 @@
+import { Component, ComputedRef } from 'vue';
+import { FileType, FileTypeMatcher, Attachment } from '../index.type';
+interface UseFileTypeOptions {
+    /**
+     * 自定义图标
+     */
+    customIcons?: Record<string, Component>;
+    /**
+     * 自定义文件类型匹配器
+     */
+    fileMatchers?: FileTypeMatcher[];
+}
+export declare function useFileType(options?: UseFileTypeOptions): {
+    detectFileType: (file: File | string) => FileType;
+    generateID: () => string;
+    formatFileSize: (size: number) => string;
+    normalizeAttachments: (items: (Attachment | Partial<Attachment>)[]) => Attachment[];
+    getIconComponent: (fileType?: FileType) => ComputedRef<Component>;
+};
+export {};

package/dist/attachments/composables/useImagePreview.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { Attachment, AttachmentListEmits } from '../index.type';
+export interface ImagePreviewOptions {
+    /**
+     * 是否启用下载功能
+     */
+    enableDownload?: boolean;
+    /**
+     * 自定义下载处理函数
+     */
+    onDownload?: (event: MouseEvent, file: Attachment) => void;
+}
+export declare function useImagePreview(fileList: Ref<Attachment[]>, emit: AttachmentListEmits, options?: ImagePreviewOptions): {
+    handlePreview: (event: MouseEvent, file: Attachment) => void;
+    renderPreview: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }> | null;
+};

package/dist/attachments/composables/useListType.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { Attachment, DisplayVariant } from '../index.type';
+/**
+ * 处理listType自动检测的组合函数
+ * @param fileList 文件列表的响应式引用
+ * @param specifiedListType 用户指定的listType
+ * @returns 实际使用的listType
+ */
+export declare function useListType(fileList: Ref<Attachment[]>, specifiedListType?: DisplayVariant): {
+    actualListType: import('vue').ComputedRef<"picture" | "card">;
+};

package/dist/attachments/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+import { default as Attachments } from './index.vue';
+declare const install: <T>(app: App<T>) => void;
+declare const _default: typeof Attachments & {
+    install: typeof install;
+};
+export default _default;

package/dist/attachments/index.js

@@ -500,7 +500,7 @@ const Ee = ["data-file-type"], Se = {
       ], 10, Ee);
     };
   }
-}), at = /* @__PURE__ */ V(rt, [["__scopeId", "data-v-e11420c5"]]), st = { class: "tr-attachments" }, it = /* @__PURE__ */ z({
+}), at = /* @__PURE__ */ V(rt, [["__scopeId", "data-v-1772c0c6"]]), st = { class: "tr-attachments" }, it = /* @__PURE__ */ z({
   __name: "index",
   props: {
     items: {},
@@ -572,7 +572,7 @@ const Ee = ["data-file-type"], Se = {
       (o(), M(Y(m(I)())))
     ]));
   }
-}), A = /* @__PURE__ */ V(it, [["__scopeId", "data-v-4c01337e"]]);
+}), A = /* @__PURE__ */ V(it, [["__scopeId", "data-v-935ed86d"]]);
 A.name = "TrAttachments";
 const ot = function(e) {
   e.component(A.name, A);

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

@@ -0,0 +1,70 @@
+import { Component } from 'vue';
+export type BaseFileType = 'image' | 'pdf' | 'word' | 'excel' | 'ppt' | 'folder' | 'other';
+export type FileType = BaseFileType | string;
+export type FileStatus = 'uploading' | 'success' | 'error';
+export type DisplayVariant = 'picture' | 'card' | 'auto';
+export interface FileTypeMatcher {
+    type: string;
+    matcher: (file: File | string) => boolean;
+    icon?: Component;
+}
+export interface BaseAttachment {
+    id?: string;
+    name?: string;
+    status?: FileStatus;
+    fileType?: FileType;
+    message?: string;
+}
+export interface UrlAttachment extends BaseAttachment {
+    url: string;
+    size?: number;
+    rawFile?: File;
+}
+export interface RawFileAttachment extends BaseAttachment {
+    rawFile: File;
+    url?: string;
+    size?: number;
+}
+export type Attachment = UrlAttachment | RawFileAttachment;
+export interface ActionButton {
+    type: string;
+    label: string;
+    handler?: (file: Attachment) => void;
+}
+export interface AttachmentListProps {
+    items?: Attachment[];
+    disabled?: boolean;
+    wrap?: boolean;
+    fileIcons?: Record<string, Component>;
+    actions?: ActionButton[];
+    variant?: DisplayVariant;
+    fileMatchers?: FileTypeMatcher[];
+}
+export interface AttachmentListEmits {
+    (e: 'update:items', items: Attachment[]): void;
+    (e: 'remove', file: Attachment): void;
+    (e: 'download', event: MouseEvent, file: Attachment): void;
+    (e: 'retry', file: Attachment): void;
+    (e: 'preview', event: MouseEvent, file: Attachment): void;
+    (e: 'action', payload: {
+        action: ActionButton;
+        file: Attachment;
+    }): void;
+}
+type BaseCardProps = Pick<AttachmentListProps, 'fileIcons' | 'disabled' | 'actions' | 'fileMatchers'>;
+export interface FileCardProps extends BaseCardProps {
+    file: Attachment;
+    variant: 'picture' | 'card';
+    showStatus?: boolean;
+}
+export interface FileCardEmits {
+    (e: 'remove', file: Attachment): void;
+    (e: 'preview', event: MouseEvent, file: Attachment): void;
+    (e: 'download', event: MouseEvent, file: Attachment): void;
+    (e: 'retry', file: Attachment): void;
+    (e: 'action', payload: {
+        action: ActionButton;
+        file: Attachment;
+    }): void;
+}
+export {};

package/dist/attachments/index.vue.d.ts

@@ -0,0 +1,27 @@
+import { AttachmentListProps, Attachment, ActionButton } from './index.type';
+declare const _default: import('vue').DefineComponent<AttachmentListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:items": (items: Attachment[]) => any;
+    remove: (file: Attachment) => any;
+    download: (event: MouseEvent, file: Attachment) => any;
+    retry: (file: Attachment) => any;
+    preview: (event: MouseEvent, file: Attachment) => any;
+    action: (payload: {
+        action: ActionButton;
+        file: Attachment;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<AttachmentListProps> & Readonly<{
+    "onUpdate:items"?: ((items: Attachment[]) => any) | undefined;
+    onRemove?: ((file: Attachment) => any) | undefined;
+    onDownload?: ((event: MouseEvent, file: Attachment) => any) | undefined;
+    onRetry?: ((file: Attachment) => any) | undefined;
+    onPreview?: ((event: MouseEvent, file: Attachment) => any) | undefined;
+    onAction?: ((payload: {
+        action: ActionButton;
+        file: Attachment;
+    }) => any) | undefined;
+}>, {
+    actions: ActionButton[];
+    fileMatchers: import('./index.type').FileTypeMatcher[];
+    variant: import('./index.type').DisplayVariant;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/attachments/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const getLastPathSegment: (value: string) => string;
+export declare const getStringDetectionCandidates: (value: string) => string[];
+export declare const getUrlDisplayName: (url: string) => string;

package/dist/base-popper/components/Popper.vue.d.ts

@@ -0,0 +1,28 @@
+import { TransitionProps } from 'vue';
+type __VLS_Props = {
+    show: boolean;
+    transitionProps?: TransitionProps;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        popperRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    popperRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    popperRef: HTMLDivElement;
+}, 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/base-popper/index.d.ts

@@ -0,0 +1,2 @@
+import { default as BasePopper } from './index.vue';
+export default BasePopper;

package/dist/base-popper/index.vue.d.ts

@@ -0,0 +1,41 @@
+import { TransitionProps, VNode } from 'vue';
+type TriggerEvents = Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
+type __VLS_Props = {
+    appendTo?: string | HTMLElement;
+    offset?: number | {
+        mainAxis?: number;
+        crossAxis?: number;
+    };
+    placement?: 'top-center' | 'bottom-center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    preventOverflow?: boolean;
+    show?: boolean;
+    transitionProps?: TransitionProps;
+    triggerEvents?: TriggerEvents;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        trigger?: () => VNode[];
+        content?: () => VNode[];
+    }> & {
+        trigger?: () => VNode[];
+        content?: () => VNode[];
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    triggerRef: import('vue').ComputedRef<HTMLElement | SVGElement | null | undefined>;
+    popperRef: import('vue').ComputedRef<HTMLDivElement | null>;
+    update: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+}, {}, {}, {}, 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/Bubble.vue.d.ts

@@ -0,0 +1,39 @@
+import { BubbleMessage, BubbleProps, BubbleSlots } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<BubbleSlots> & BubbleSlots;
+    refs: {
+        bubbleRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BubbleProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "state-change": (payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<BubbleProps> & Readonly<{
+    "onState-change"?: ((payload: {
+        key: string;
+        value: unknown;
+        messageIndex: number;
+        contentIndex: number;
+    }) => any) | undefined;
+}>, {
+    placement: "start" | "end";
+    shape: "corner" | "rounded" | "none";
+    contentRenderMode: "single" | "split";
+    contentResolver: (message: BubbleMessage) => import('./index.type').ChatMessageContent | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    bubbleRef: 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/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;
+};