@yh-ui/components 0.1.10 → 0.1.15

package/dist/ai-artifacts/src/ai-artifacts.vue.d.ts

@@ -0,0 +1,50 @@
+import 'highlight.js/styles/atom-one-dark.css';
+declare var __VLS_25: {
+    data: any;
+    title: any;
+}, __VLS_31: {
+    data: any;
+};
+type __VLS_Slots = {} & {
+    chart?: (props: typeof __VLS_25) => any;
+} & {
+    canvas?: (props: typeof __VLS_31) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly visible: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly data: {
+        readonly type: import("vue").PropType<import("./ai-artifacts").ArtifactData>;
+    };
+    readonly width: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly default: "50%";
+    };
+    readonly fullscreen: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly mode: {
+        readonly type: import("vue").PropType<"preview" | "code" | "inline">;
+        readonly default: "preview";
+    };
+    readonly themeOverrides: {
+        readonly type: import("vue").PropType<import("@yh-ui/theme").ComponentThemeVars>;
+        readonly default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any, string, import("vue").PublicProps, any, {
+    readonly themeOverrides: import("@yh-ui/theme").ComponentThemeVars;
+    readonly width: string | number;
+    readonly visible: boolean;
+    readonly fullscreen: boolean;
+    readonly mode: "inline" | "code" | "preview";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/ai-bubble/__tests__/ai-bubble.ssr.test.cjs

@@ -0,0 +1,87 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _serverRenderer = require("@vue/server-renderer");
+var _vue = require("vue");
+_vitest.vi.mock("markdown-it", async () => {
+  class MockMd {
+    inline = {
+      ruler: {
+        after: _vitest.vi.fn()
+      }
+    };
+    render(content) {
+      return `<p>${content}</p>`;
+    }
+  }
+  return {
+    default: MockMd
+  };
+});
+_vitest.vi.mock("highlight.js", () => ({
+  default: {
+    getLanguage: () => false,
+    highlight: _vitest.vi.fn()
+  }
+}));
+_vitest.vi.mock("highlight.js/styles/atom-one-dark.css", () => ({}));
+const {
+  default: AiBubble
+} = await Promise.resolve().then(() => require("../src/ai-bubble.vue"));
+(0, _vitest.describe)("YhAiBubble SSR", () => {
+  (0, _vitest.it)("should render to string on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "SSR hello",
+      role: "assistant"
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble");
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble--assistant");
+  });
+  (0, _vitest.it)("should render user role on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "User msg",
+      role: "user"
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble--user");
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble--placement-end");
+  });
+  (0, _vitest.it)("should render time on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "hi",
+      time: "09:30",
+      role: "assistant"
+    }));
+    (0, _vitest.expect)(html).toContain("09:30");
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble__time");
+  });
+  (0, _vitest.it)("should render loading state on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "",
+      loading: true
+    }));
+    (0, _vitest.expect)(html).toContain("is-loading");
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble__typing-indicator");
+  });
+  (0, _vitest.it)("should not render avatar for system role on server", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "sys",
+      role: "system"
+    }));
+    (0, _vitest.expect)(html).not.toContain("yh-ai-bubble__avatar");
+  });
+  (0, _vitest.it)("should render markdown class when markdown=true", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "hello",
+      markdown: true
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble__markdown");
+  });
+  (0, _vitest.it)("should render plain text class when markdown=false", async () => {
+    const html = await (0, _serverRenderer.renderToString)((0, _vue.h)(AiBubble, {
+      content: "plain",
+      markdown: false
+    }));
+    (0, _vitest.expect)(html).toContain("yh-ai-bubble__text");
+    (0, _vitest.expect)(html).toContain("plain");
+  });
+});

package/dist/ai-bubble/__tests__/ai-bubble.ssr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ai-bubble/__tests__/ai-bubble.ssr.test.mjs

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderToString } from "@vue/server-renderer";
+import { h } from "vue";
+vi.mock("markdown-it", async () => {
+  class MockMd {
+    inline = {
+      ruler: {
+        after: vi.fn()
+      }
+    };
+    render(content) {
+      return `<p>${content}</p>`;
+    }
+  }
+  return { default: MockMd };
+});
+vi.mock("highlight.js", () => ({
+  default: { getLanguage: () => false, highlight: vi.fn() }
+}));
+vi.mock("highlight.js/styles/atom-one-dark.css", () => ({}));
+const { default: AiBubble } = await import("../src/ai-bubble.vue");
+describe("YhAiBubble SSR", () => {
+  it("should render to string on server", async () => {
+    const html = await renderToString(h(AiBubble, { content: "SSR hello", role: "assistant" }));
+    expect(html).toContain("yh-ai-bubble");
+    expect(html).toContain("yh-ai-bubble--assistant");
+  });
+  it("should render user role on server", async () => {
+    const html = await renderToString(h(AiBubble, { content: "User msg", role: "user" }));
+    expect(html).toContain("yh-ai-bubble--user");
+    expect(html).toContain("yh-ai-bubble--placement-end");
+  });
+  it("should render time on server", async () => {
+    const html = await renderToString(
+      h(AiBubble, { content: "hi", time: "09:30", role: "assistant" })
+    );
+    expect(html).toContain("09:30");
+    expect(html).toContain("yh-ai-bubble__time");
+  });
+  it("should render loading state on server", async () => {
+    const html = await renderToString(h(AiBubble, { content: "", loading: true }));
+    expect(html).toContain("is-loading");
+    expect(html).toContain("yh-ai-bubble__typing-indicator");
+  });
+  it("should not render avatar for system role on server", async () => {
+    const html = await renderToString(h(AiBubble, { content: "sys", role: "system" }));
+    expect(html).not.toContain("yh-ai-bubble__avatar");
+  });
+  it("should render markdown class when markdown=true", async () => {
+    const html = await renderToString(h(AiBubble, { content: "hello", markdown: true }));
+    expect(html).toContain("yh-ai-bubble__markdown");
+  });
+  it("should render plain text class when markdown=false", async () => {
+    const html = await renderToString(h(AiBubble, { content: "plain", markdown: false }));
+    expect(html).toContain("yh-ai-bubble__text");
+    expect(html).toContain("plain");
+  });
+});

package/dist/ai-bubble/__tests__/ai-bubble.test.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _testUtils = require("@vue/test-utils");
+_vitest.vi.mock("markdown-it", async () => {
+  class MockMd {
+    inline = {
+      ruler: {
+        after: _vitest.vi.fn()
+      }
+    };
+    render(content) {
+      return `<p>${content}</p>`;
+    }
+  }
+  return {
+    default: MockMd
+  };
+});
+_vitest.vi.mock("highlight.js", () => ({
+  default: {
+    getLanguage: () => false,
+    highlight: _vitest.vi.fn()
+  }
+}));
+_vitest.vi.mock("highlight.js/styles/atom-one-dark.css", () => ({}));
+const {
+  default: AiBubble
+} = await Promise.resolve().then(() => require("../src/ai-bubble.vue"));
+(0, _vitest.describe)("YhAiBubble", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _vitest.afterEach)(() => {
+    _vitest.vi.restoreAllMocks();
+  });
+  (0, _vitest.it)("should render with base class", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hello",
+        role: "assistant"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should apply role class for user", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "user"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--user");
+  });
+  (0, _vitest.it)("should apply role class for assistant", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "assistant"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--assistant");
+  });
+  (0, _vitest.it)("should not render avatar for system role", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "sys msg",
+        role: "system"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__avatar").exists()).toBe(false);
+  });
+  (0, _vitest.it)("should default placement to end for user role", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "user"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--placement-end");
+  });
+  (0, _vitest.it)("should default placement to start for assistant role", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "assistant"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
+  });
+  (0, _vitest.it)("should override placement via prop", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "user",
+        placement: "start"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
+  });
+  (0, _vitest.it)("should apply shape class", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        shape: "round"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--shape-round");
+  });
+  (0, _vitest.it)("should apply variant class", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        variant: "borderless"
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("yh-ai-bubble--variant-borderless");
+  });
+  (0, _vitest.it)("should show loading indicator when loading=true and content is empty", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        loading: true,
+        content: ""
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-loading");
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should not show typing indicator when content exists even if loading=true", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        loading: true,
+        content: "some text"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(false);
+  });
+  (0, _vitest.it)("should render plain text when markdown=false", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "plain text",
+        markdown: false
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__text").text()).toBe("plain text");
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(false);
+  });
+  (0, _vitest.it)("should render markdown container when markdown=true", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hello",
+        markdown: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render time when provided", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        time: "10:00"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__time").text()).toBe("10:00");
+  });
+  (0, _vitest.it)("should not render header without time and header slot", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi"
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__header").exists()).toBe(false);
+  });
+  (0, _vitest.it)("should apply is-typing class when typing=true", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        typing: true
+      }
+    });
+    (0, _vitest.expect)(wrapper.classes()).toContain("is-typing");
+  });
+  (0, _vitest.it)("should render content via default slot", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      slots: {
+        default: '<span class="custom-content">Custom</span>'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".custom-content").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render footer slot when provided", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi"
+      },
+      slots: {
+        footer: '<div class="custom-footer">Actions</div>'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__footer").exists()).toBe(true);
+    (0, _vitest.expect)(wrapper.find(".custom-footer").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render header slot when provided", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi"
+      },
+      slots: {
+        header: '<span class="custom-header">Header</span>'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".yh-ai-bubble__header").exists()).toBe(true);
+    (0, _vitest.expect)(wrapper.find(".custom-header").exists()).toBe(true);
+  });
+  (0, _vitest.it)("should render avatar slot when provided", () => {
+    const wrapper = (0, _testUtils.mount)(AiBubble, {
+      props: {
+        content: "hi",
+        role: "user"
+      },
+      slots: {
+        avatar: '<img class="custom-avatar" src="test.png" />'
+      }
+    });
+    (0, _vitest.expect)(wrapper.find(".custom-avatar").exists()).toBe(true);
+  });
+});

package/dist/ai-bubble/__tests__/ai-bubble.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ai-bubble/__tests__/ai-bubble.test.mjs

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mount } from "@vue/test-utils";
+vi.mock("markdown-it", async () => {
+  class MockMd {
+    inline = {
+      ruler: {
+        after: vi.fn()
+      }
+    };
+    render(content) {
+      return `<p>${content}</p>`;
+    }
+  }
+  return { default: MockMd };
+});
+vi.mock("highlight.js", () => ({
+  default: { getLanguage: () => false, highlight: vi.fn() }
+}));
+vi.mock("highlight.js/styles/atom-one-dark.css", () => ({}));
+const { default: AiBubble } = await import("../src/ai-bubble.vue");
+describe("YhAiBubble", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  it("should render with base class", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hello", role: "assistant" } });
+    expect(wrapper.find(".yh-ai-bubble").exists()).toBe(true);
+  });
+  it("should apply role class for user", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--user");
+  });
+  it("should apply role class for assistant", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", role: "assistant" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--assistant");
+  });
+  it("should not render avatar for system role", () => {
+    const wrapper = mount(AiBubble, { props: { content: "sys msg", role: "system" } });
+    expect(wrapper.find(".yh-ai-bubble__avatar").exists()).toBe(false);
+  });
+  it("should default placement to end for user role", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-end");
+  });
+  it("should default placement to start for assistant role", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", role: "assistant" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
+  });
+  it("should override placement via prop", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", role: "user", placement: "start" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--placement-start");
+  });
+  it("should apply shape class", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", shape: "round" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--shape-round");
+  });
+  it("should apply variant class", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", variant: "borderless" } });
+    expect(wrapper.classes()).toContain("yh-ai-bubble--variant-borderless");
+  });
+  it("should show loading indicator when loading=true and content is empty", () => {
+    const wrapper = mount(AiBubble, { props: { loading: true, content: "" } });
+    expect(wrapper.classes()).toContain("is-loading");
+    expect(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(true);
+  });
+  it("should not show typing indicator when content exists even if loading=true", () => {
+    const wrapper = mount(AiBubble, { props: { loading: true, content: "some text" } });
+    expect(wrapper.find(".yh-ai-bubble__typing-indicator").exists()).toBe(false);
+  });
+  it("should render plain text when markdown=false", () => {
+    const wrapper = mount(AiBubble, { props: { content: "plain text", markdown: false } });
+    expect(wrapper.find(".yh-ai-bubble__text").text()).toBe("plain text");
+    expect(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(false);
+  });
+  it("should render markdown container when markdown=true", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hello", markdown: true } });
+    expect(wrapper.find(".yh-ai-bubble__markdown").exists()).toBe(true);
+  });
+  it("should render time when provided", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", time: "10:00" } });
+    expect(wrapper.find(".yh-ai-bubble__time").text()).toBe("10:00");
+  });
+  it("should not render header without time and header slot", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi" } });
+    expect(wrapper.find(".yh-ai-bubble__header").exists()).toBe(false);
+  });
+  it("should apply is-typing class when typing=true", () => {
+    const wrapper = mount(AiBubble, { props: { content: "hi", typing: true } });
+    expect(wrapper.classes()).toContain("is-typing");
+  });
+  it("should render content via default slot", () => {
+    const wrapper = mount(AiBubble, {
+      slots: { default: '<span class="custom-content">Custom</span>' }
+    });
+    expect(wrapper.find(".custom-content").exists()).toBe(true);
+  });
+  it("should render footer slot when provided", () => {
+    const wrapper = mount(AiBubble, {
+      props: { content: "hi" },
+      slots: { footer: '<div class="custom-footer">Actions</div>' }
+    });
+    expect(wrapper.find(".yh-ai-bubble__footer").exists()).toBe(true);
+    expect(wrapper.find(".custom-footer").exists()).toBe(true);
+  });
+  it("should render header slot when provided", () => {
+    const wrapper = mount(AiBubble, {
+      props: { content: "hi" },
+      slots: { header: '<span class="custom-header">Header</span>' }
+    });
+    expect(wrapper.find(".yh-ai-bubble__header").exists()).toBe(true);
+    expect(wrapper.find(".custom-header").exists()).toBe(true);
+  });
+  it("should render avatar slot when provided", () => {
+    const wrapper = mount(AiBubble, {
+      props: { content: "hi", role: "user" },
+      slots: { avatar: '<img class="custom-avatar" src="test.png" />' }
+    });
+    expect(wrapper.find(".custom-avatar").exists()).toBe(true);
+  });
+});

package/dist/ai-bubble/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  YhAiBubble: true
+};
+module.exports = exports.YhAiBubble = void 0;
+var _utils = require("@yh-ui/utils");
+var _aiBubble = _interopRequireDefault(require("./src/ai-bubble.vue"));
+var _aiBubble2 = require("./src/ai-bubble.cjs");
+Object.keys(_aiBubble2).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _aiBubble2[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _aiBubble2[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const YhAiBubble = exports.YhAiBubble = (0, _utils.withInstall)(_aiBubble.default);
+module.exports = YhAiBubble;

package/dist/ai-bubble/index.d.ts

@@ -0,0 +1,3 @@
+export declare const YhAiBubble: any;
+export default YhAiBubble;
+export * from './src/ai-bubble';

package/dist/ai-bubble/index.mjs

@@ -0,0 +1,5 @@
+import { withInstall } from "@yh-ui/utils";
+import AiBubble from "./src/ai-bubble.vue";
+export const YhAiBubble = withInstall(AiBubble);
+export default YhAiBubble;
+export * from "./src/ai-bubble.mjs";

package/dist/ai-bubble/src/ai-bubble.cjs

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.aiBubbleProps = void 0;
+const aiBubbleProps = exports.aiBubbleProps = {
+  /**
+   * 气泡内容，支持 Markdown
+   */
+  content: {
+    type: String,
+    default: ""
+  },
+  /**
+   * 是否开启 Markdown 解析
+   */
+  markdown: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * 角色：用户、助手或系统
+   */
+  role: {
+    type: String,
+    default: "assistant"
+  },
+  /**
+   * 气泡位置
+   */
+  placement: {
+    type: String
+  },
+  /**
+   * 气泡形状
+   */
+  shape: {
+    type: String,
+    default: "round"
+  },
+  /**
+   * 视觉变体
+   */
+  variant: {
+    type: String,
+    default: "filled"
+  },
+  /**
+   * 显示时间
+   */
+  time: String,
+  /**
+   * 头像地址
+   */
+  avatar: String,
+  /**
+   * 是否在加载中
+   */
+  loading: Boolean,
+  /**
+   * 打字机特效
+   */
+  typing: Boolean,
+  /**
+   * 引用来源列表 (Citations)
+   */
+  citations: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * 多模态内容 (图片、音频、文件等)
+   */
+  multimodal: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * 主题覆盖变量
+   */
+  themeOverrides: {
+    type: Object,
+    default: void 0
+  }
+};