@opentiny/tiny-robot 0.4.2-alpha.9 → 0.5.1-alpha.1

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

@@ -0,0 +1,111 @@
+import { ComponentPublicInstance, VNode } from 'vue';
+export type LayoutSide = 'left' | 'right';
+export type LayoutAsideMode = 'dock' | 'drawer';
+export type LayoutAsideCollapseEffect = 'overlay' | 'slide';
+export type LayoutMode = 'normal' | 'floating';
+export type LayoutFloatingPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center';
+export interface LayoutFloatingState {
+    placement: LayoutFloatingPlacement;
+    offsetX: number;
+    offsetY: number;
+    width: number;
+    height: number;
+}
+export interface LayoutFloatingOptions {
+    draggable?: boolean;
+    resizable?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+export type LayoutFloatingResizeHandle = 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+export interface LayoutAsideOpenDetail {
+    side: LayoutSide;
+    open: boolean;
+}
+export interface LayoutAsideOpenValue {
+    open: boolean;
+}
+export interface LayoutAsideResizeDetail {
+    side: LayoutSide;
+    expandedWidth: number;
+}
+export interface LayoutAsideResizeValue {
+    expandedWidth: number;
+}
+export type LayoutFloatingDragDetail = LayoutFloatingState;
+export type LayoutFloatingResizeDetail = LayoutFloatingState & {
+    handle: LayoutFloatingResizeHandle;
+};
+export interface LayoutAsideOptions {
+    mode?: LayoutAsideMode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    expandedWidth?: number;
+    defaultExpandedWidth?: number;
+    minExpandedWidth?: number;
+    maxExpandedWidth?: number;
+    collapsedWidth?: number;
+    collapseEffect?: LayoutAsideCollapseEffect;
+    resizable?: boolean;
+}
+export interface LayoutAsidePanelsProps {
+    leftAside?: LayoutAsideOptions;
+    rightAside?: LayoutAsideOptions;
+}
+export interface LayoutNormalProps extends LayoutAsidePanelsProps {
+    mode: 'normal';
+    floatingState?: never;
+    defaultFloatingState?: never;
+    floatingOptions?: never;
+}
+type LayoutFloatingStateControlProps = {
+    floatingState?: LayoutFloatingState;
+    defaultFloatingState?: never;
+} | {
+    floatingState?: never;
+    defaultFloatingState?: LayoutFloatingState;
+};
+export type LayoutFloatingProps = LayoutAsidePanelsProps & LayoutFloatingStateControlProps & {
+    mode: 'floating';
+    floatingOptions?: LayoutFloatingOptions;
+};
+export type LayoutProps = LayoutNormalProps | LayoutFloatingProps;
+export type LayoutScrollTargetComponent = Pick<ComponentPublicInstance, '$el'>;
+export type LayoutScrollTarget = HTMLElement | LayoutScrollTargetComponent | null | undefined;
+export interface LayoutProxyScrollbarProps {
+    scrollTarget?: LayoutScrollTarget;
+}
+export interface LayoutAsideToggleProps {
+    side: LayoutSide;
+}
+export interface LayoutEmits {
+    'update:floatingState': [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];
+    'aside-open-change': [detail: LayoutAsideOpenDetail];
+    'aside-resize-start': [detail: LayoutAsideResizeDetail];
+    'aside-resize': [detail: LayoutAsideResizeDetail];
+    'aside-resize-end': [detail: LayoutAsideResizeDetail];
+    'left-aside-open-change': [detail: LayoutAsideOpenValue];
+    'left-aside-resize-start': [detail: LayoutAsideResizeValue];
+    'left-aside-resize': [detail: LayoutAsideResizeValue];
+    'left-aside-resize-end': [detail: LayoutAsideResizeValue];
+    'right-aside-open-change': [detail: LayoutAsideOpenValue];
+    'right-aside-resize-start': [detail: LayoutAsideResizeValue];
+    'right-aside-resize': [detail: LayoutAsideResizeValue];
+    'right-aside-resize-end': [detail: LayoutAsideResizeValue];
+}
+export interface LayoutSlots {
+    'left-aside'?: () => VNode | VNode[];
+    header?: () => VNode | VNode[];
+    main?: () => VNode | VNode[];
+    footer?: () => VNode | VNode[];
+    'right-aside'?: () => VNode | VNode[];
+}
+export {};

package/dist/layout/internal.type.d.ts

@@ -0,0 +1,43 @@
+import { ComputedRef, Ref } from 'vue';
+import { LayoutAsideCollapseEffect, LayoutFloatingOptions, LayoutFloatingState, LayoutMode, LayoutSide } from './index.type';
+export type LayoutResolvedFloating = LayoutFloatingState & LayoutFloatingOptions;
+export interface LayoutSurfaceProps {
+    mode: LayoutMode;
+    floatingState?: LayoutFloatingState;
+    floatingOptions?: LayoutFloatingOptions;
+}
+export interface LayoutFloatingRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LayoutFloatingDragPosition {
+    x: number;
+    y: number;
+}
+export interface LayoutAsideState {
+    side: LayoutSide;
+    isOpen: ComputedRef<boolean>;
+    expandedWidth: ComputedRef<number>;
+    collapsedWidth: ComputedRef<number>;
+    collapseEffect: ComputedRef<LayoutAsideCollapseEffect>;
+    minExpandedWidth: ComputedRef<number>;
+    maxExpandedWidth: ComputedRef<number>;
+    isDock: ComputedRef<boolean>;
+    isDrawer: ComputedRef<boolean>;
+    isRail: ComputedRef<boolean>;
+    isHidden: ComputedRef<boolean>;
+    canResize: ComputedRef<boolean>;
+    setOpen: (nextOpen: boolean) => void;
+    setExpandedWidth: (nextWidth: number) => void;
+}
+export interface LayoutAsideToggleContext {
+    isOpen: ComputedRef<boolean>;
+    toggle: () => void;
+}
+export interface LayoutContext {
+    rootEl: Ref<HTMLElement | null>;
+    left: LayoutAsideToggleContext;
+    right: LayoutAsideToggleContext;
+}

package/dist/layout/utils/asideEventEmitters.d.ts

@@ -0,0 +1,6 @@
+import { LayoutAsideOpenDetail, LayoutAsideResizeDetail, LayoutEmits } from '../index.type';
+type LayoutEmit = <K extends keyof LayoutEmits>(event: K, ...args: LayoutEmits[K]) => void;
+export type LayoutAsideResizePhase = 'start' | 'resize' | 'end';
+export declare function emitAsideOpenChangeEvents(emit: LayoutEmit, detail: LayoutAsideOpenDetail): void;
+export declare function emitAsideResizeEvents(emit: LayoutEmit, phase: LayoutAsideResizePhase, detail: LayoutAsideResizeDetail): void;
+export {};

package/dist/layout/utils/asidePresets.d.ts

@@ -0,0 +1,5 @@
+import { LayoutSide } from '../index.type';
+export declare function getDefaultAsideOpen(side: LayoutSide): boolean;
+export declare function getDefaultAsideMinWidth(side: LayoutSide): number;
+export declare function getDefaultAsideExpandedWidth(side: LayoutSide): number;
+export declare function getDefaultAsideMaxWidth(side: LayoutSide): number;

package/dist/layout/utils/cssLength.d.ts

@@ -0,0 +1,2 @@
+export declare function toPx(value: number | undefined): string | undefined;
+export declare function resolveCssLengthToPx(value: number | string | undefined, fallback: number): number;

package/dist/layout/utils/domInteraction.d.ts

@@ -0,0 +1 @@
+export declare function lockBodyDragInteraction(body: HTMLElement, cursor: string): () => void;

package/dist/layout/utils/number.d.ts

@@ -0,0 +1 @@
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/layout/utils/surfaceGeometry.d.ts

@@ -0,0 +1,87 @@
+import { LayoutFloatingOptions, LayoutFloatingResizeHandle, LayoutFloatingState } from '../index.type';
+import { LayoutFloatingRect } from '../internal.type';
+export interface FloatingBounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface FloatingConstraints {
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+}
+export declare const DEFAULT_FLOATING_WIDTH = 420;
+export declare const DEFAULT_FLOATING_HEIGHT = 560;
+export declare const DEFAULT_FLOATING_GAP = 0;
+export declare const DEFAULT_FLOATING_TOP = 0;
+export declare const DEFAULT_FLOATING_OFFSET = 24;
+export declare const DEFAULT_MIN_FLOATING_WIDTH = 320;
+export declare const DEFAULT_MIN_FLOATING_HEIGHT = 240;
+type FloatingStateInput = LayoutFloatingState & Partial<LayoutFloatingOptions>;
+type FloatingRectInput = Pick<LayoutFloatingRect, 'x' | 'y' | 'width' | 'height'>;
+type FloatingInput = LayoutFloatingRect | FloatingStateInput | undefined;
+/**
+ * 根据视口尺寸返回可用边界。
+ * @param viewportWidth 视口宽度。
+ * @param viewportHeight 视口高度。
+ * @param gap 视口左右边距。
+ * @param topGap 视口顶部边距。
+ * @returns 视口边界。
+ */
+export declare function resolveViewportBounds(viewportWidth?: number, viewportHeight?: number, gap?: number, topGap?: number): FloatingBounds;
+/**
+ * @param bounds 视口边界。
+ * @param source 浮层尺寸配置。
+ * @returns 浮层尺寸约束。
+ */
+export declare function resolveFloatingConstraints(bounds: FloatingBounds, source?: Partial<LayoutFloatingOptions>): FloatingConstraints;
+/**
+ * 对 rect 做尺寸和位置裁剪，返回完整 rect。
+ * @param rect 浮层 rect 输入。
+ * @param bounds 视口边界。
+ * @param constraints 浮层尺寸约束。
+ * @returns 规范化后的浮层 rect。
+ */
+export declare function clampFloatingRect(rect: FloatingRectInput, bounds: FloatingBounds, constraints?: FloatingConstraints): LayoutFloatingRect;
+/**
+ * 根据拖拽的边或角裁剪 rect。
+ * @param rect 浮层 rect 输入。
+ * @param handle 当前 resize handle。
+ * @param bounds 视口边界。
+ * @param constraints 浮层尺寸约束。
+ * @returns 裁剪后的浮层 rect。
+ */
+export declare function clampFloatingRectByHandle(rect: FloatingRectInput, handle: LayoutFloatingResizeHandle, bounds: FloatingBounds, constraints?: FloatingConstraints): LayoutFloatingRect;
+/**
+ * 根据 floatingState 和 floatingOptions 生成初始 rect。
+ * @param bounds 视口边界。
+ * @param source 浮层状态和配置输入。
+ * @returns 初始浮层 rect。
+ */
+export declare function createFloatingRectFromState(bounds: FloatingBounds, source?: FloatingStateInput): LayoutFloatingRect;
+/**
+ * 把输入态的 floatingState 或 rect 统一整理成几何计算使用的 rect。
+ * @param input 浮层输入。
+ * @param bounds 视口边界。
+ * @returns 规范化后的浮层 rect。
+ */
+export declare function resolveFloatingRect(input: FloatingInput, bounds: FloatingBounds): LayoutFloatingRect;
+/**
+ * 根据 rect 反推出对外的 floatingState。
+ * @param rect 浮层 rect。
+ * @param bounds 视口边界。
+ * @param source 浮层状态来源。
+ * @param normalizeCenter 是否把 center 转为最近角落。
+ * @returns 对外 floatingState。
+ */
+export declare function resolveFloatingStateFromRect(rect: LayoutFloatingRect, bounds: FloatingBounds, source?: Partial<FloatingStateInput>, normalizeCenter?: boolean): LayoutFloatingState;
+/**
+ * 比较两个 rect 的几何信息是否一致。
+ * @param left 左侧 rect。
+ * @param right 右侧 rect。
+ * @returns 两者几何信息是否一致。
+ */
+export declare function areFloatingGeometryEqual(left: Pick<LayoutFloatingRect, 'x' | 'y' | 'width' | 'height'> | undefined, right: Pick<LayoutFloatingRect, 'x' | 'y' | 'width' | 'height'> | undefined): boolean;
+export {};

package/dist/layout/utils/surfaceResize.d.ts

@@ -0,0 +1,10 @@
+import { LayoutFloatingResizeHandle } from '../index.type';
+import { LayoutFloatingRect } from '../internal.type';
+interface ResolveFloatingResizeRectOptions {
+    handle: LayoutFloatingResizeHandle;
+    deltaX: number;
+    deltaY: number;
+    startRect: LayoutFloatingRect;
+}
+export declare function resolveFloatingResizeRect(options: ResolveFloatingResizeRectOptions): LayoutFloatingRect;
+export {};

package/dist/mcp-add-form/components/CodeEditor.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_PublicProps = {
+    'codeData': string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:codeData": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:codeData"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/mcp-add-form/components/FormEditor.vue.d.ts

@@ -0,0 +1,10 @@
+import { McpAddFormData } from '../index.type';
+type __VLS_PublicProps = {
+    'formData': McpAddFormData;
+};
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:formData": (value: McpAddFormData) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:formData"?: ((value: McpAddFormData) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFormElement>;
+export default _default;

package/dist/mcp-add-form/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FormEditor } from './FormEditor.vue';
+export { default as CodeEditor } from './CodeEditor.vue';

package/dist/mcp-add-form/index.d.ts

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

package/dist/mcp-add-form/index.type.d.ts

@@ -0,0 +1,19 @@
+export type AddType = 'form' | 'code';
+export interface McpAddFormData {
+    name: string;
+    description: string;
+    type: 'sse' | 'streamableHttp';
+    url: string;
+    headers: string;
+    thumbnail?: File | null;
+}
+export interface McpAddFormProps {
+    addType?: AddType;
+    formData?: McpAddFormData;
+    codeData?: string;
+}
+export interface McpAddFormEmits {
+    (e: 'update:addType', value: AddType): void;
+    (e: 'confirm', type: AddType, data: McpAddFormData | string): void;
+    (e: 'cancel'): void;
+}

package/dist/mcp-add-form/index.vue.d.ts

@@ -0,0 +1,13 @@
+import { McpAddFormData, AddType, McpAddFormProps } from './index.type';
+declare const _default: import('vue').DefineComponent<McpAddFormProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    cancel: () => any;
+    confirm: (type: AddType, data: string | McpAddFormData) => any;
+    "update:addType": (value: AddType) => any;
+}, string, import('vue').PublicProps, Readonly<McpAddFormProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: ((type: AddType, data: string | McpAddFormData) => any) | undefined;
+    "onUpdate:addType"?: ((value: AddType) => any) | undefined;
+}>, {
+    addType: AddType;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/mcp-server-picker/components/NoData.vue.d.ts

@@ -0,0 +1,7 @@
+interface EmptyStateProps {
+    searchQuery: string;
+}
+declare const _default: import('vue').DefineComponent<EmptyStateProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EmptyStateProps> & Readonly<{}>, {
+    searchQuery: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/mcp-server-picker/components/PluginCard.vue.d.ts

@@ -0,0 +1,40 @@
+import { PluginCardProps, PluginInfo } from '../index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        actions?(_: {
+            plugin: PluginInfo;
+            expanded: boolean;
+            mode: import('../index.type').PluginCardMode;
+        }): any;
+        'expand-icon'?(_: {
+            expanded: boolean;
+        }): any;
+        'delete-icon'?(_: {}): any;
+        'add-button'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<PluginCardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "toggle-plugin": (enabled: boolean) => any;
+    "toggle-tool": (toolId: string, enabled: boolean) => any;
+    "add-plugin": (plugin: PluginInfo) => any;
+    "delete-plugin": () => any;
+}, string, import('vue').PublicProps, Readonly<PluginCardProps> & Readonly<{
+    "onToggle-plugin"?: ((enabled: boolean) => any) | undefined;
+    "onToggle-tool"?: ((toolId: string, enabled: boolean) => any) | undefined;
+    "onAdd-plugin"?: ((plugin: PluginInfo) => any) | undefined;
+    "onDelete-plugin"?: (() => any) | undefined;
+}>, {
+    mode: import('../index.type').PluginCardMode;
+    showToolCount: boolean;
+}, {}, {}, {}, 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/mcp-server-picker/components/PluginModal.vue.d.ts

@@ -0,0 +1,15 @@
+type __VLS_PublicProps = {
+    'visible': boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+} & {
+    confirm: (type: "code" | "form", data: import('../index.type').PluginCreationData) => any;
+    "update:visible": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onConfirm?: ((type: "code" | "form", data: import('../index.type').PluginCreationData) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    dialogRef: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/mcp-server-picker/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as PluginCard } from './PluginCard.vue';
+export { default as PluginModal } from './PluginModal.vue';
+export { default as NoData } from './NoData.vue';

package/dist/mcp-server-picker/index.d.ts

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

package/dist/mcp-server-picker/index.type.d.ts

@@ -0,0 +1,99 @@
+export interface PluginTool {
+    id: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+}
+export type PluginAddState = 'idle' | 'loading' | 'added';
+export interface PluginInfo {
+    id: string;
+    name: string;
+    icon: string;
+    description: string;
+    enabled: boolean;
+    expanded?: boolean;
+    tools: PluginTool[];
+    addState?: PluginAddState;
+    category?: string;
+}
+export type PluginCardMode = 'installed' | 'market';
+export interface PluginCardProps {
+    plugin: PluginInfo;
+    mode?: PluginCardMode;
+    showToolCount?: boolean;
+}
+export interface PluginCardEmits {
+    (e: 'toggle-plugin', enabled: boolean): void;
+    (e: 'toggle-tool', toolId: string, enabled: boolean): void;
+    (e: 'add-plugin', plugin: PluginInfo): void;
+    (e: 'delete-plugin'): void;
+}
+export interface MarketCategoryOption {
+    value: string;
+    label: string;
+}
+export interface PopupConfig {
+    type: 'fixed' | 'drawer';
+    position?: {
+        top?: string | number;
+        left?: string | number;
+        right?: string | number;
+        bottom?: string | number;
+    };
+    drawer?: {
+        direction: 'left' | 'right';
+    };
+}
+export interface PluginFormData {
+    name: string;
+    description: string;
+    type: 'sse' | 'streamableHttp';
+    url: string;
+    headers: string;
+    thumbnail?: File | null;
+}
+export type PluginCreationData = PluginFormData | string;
+export interface PluginModalEmits {
+    (e: 'update:visible', value: boolean): void;
+    (e: 'confirm', type: 'form' | 'code', data: PluginCreationData): void;
+}
+export interface McpServerPickerProps {
+    installedPlugins?: PluginInfo[];
+    marketPlugins?: PluginInfo[];
+    searchPlaceholder?: string;
+    enableSearch?: boolean;
+    installedSearchFn?: (query: string, item: PluginInfo) => boolean;
+    marketSearchFn?: (query: string, item: PluginInfo) => boolean;
+    marketCategoryOptions?: MarketCategoryOption[];
+    marketCategoryPlaceholder?: string;
+    enableMarketCategoryFilter?: boolean;
+    defaultActiveTab?: 'installed' | 'market';
+    showInstalledTab?: boolean;
+    showMarketTab?: boolean;
+    visible?: boolean;
+    popupConfig?: PopupConfig;
+    activeCount?: number;
+    installedTabTitle?: string;
+    marketTabTitle?: string;
+    title?: string;
+    showCustomAddButton?: boolean;
+    customAddButtonText?: string;
+    allowPluginToggle?: boolean;
+    allowToolToggle?: boolean;
+    allowPluginDelete?: boolean;
+    allowPluginAdd?: boolean;
+    loading?: boolean;
+    marketLoading?: boolean;
+}
+export interface McpServerPickerEmits {
+    (e: 'market-category-change', category: string): void;
+    (e: 'tab-change', activeTab: 'installed' | 'market'): void;
+    (e: 'plugin-toggle', plugin: PluginInfo, enabled: boolean): void;
+    (e: 'plugin-delete', plugin: PluginInfo): void;
+    (e: 'plugin-add', plugin: PluginInfo): void;
+    (e: 'plugin-create', type: 'form' | 'code', data: PluginCreationData): void;
+    (e: 'tool-toggle', plugin: PluginInfo, toolId: string, enabled: boolean): void;
+    (e: 'refresh', tab: 'installed' | 'market'): void;
+    (e: 'update:activeCount', count: number): void;
+    (e: 'update:visible', visible: boolean): void;
+}

package/dist/mcp-server-picker/index.vue.d.ts

@@ -0,0 +1,71 @@
+import { PluginInfo, McpServerPickerProps, PluginCreationData, PopupConfig } from './index.type';
+type __VLS_Props = McpServerPickerProps;
+type __VLS_PublicProps = {
+    'visible': boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'header-actions'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+} & {
+    refresh: (tab: "installed" | "market") => any;
+    "update:visible": (visible: boolean) => any;
+    "market-category-change": (category: string) => any;
+    "tab-change": (activeTab: "installed" | "market") => any;
+    "plugin-toggle": (plugin: PluginInfo, enabled: boolean) => any;
+    "plugin-delete": (plugin: PluginInfo) => any;
+    "plugin-add": (plugin: PluginInfo) => any;
+    "plugin-create": (type: "code" | "form", data: PluginCreationData) => any;
+    "tool-toggle": (plugin: PluginInfo, toolId: string, enabled: boolean) => any;
+    "update:activeCount": (count: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onRefresh?: ((tab: "installed" | "market") => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    "onMarket-category-change"?: ((category: string) => any) | undefined;
+    "onTab-change"?: ((activeTab: "installed" | "market") => any) | undefined;
+    "onPlugin-toggle"?: ((plugin: PluginInfo, enabled: boolean) => any) | undefined;
+    "onPlugin-delete"?: ((plugin: PluginInfo) => any) | undefined;
+    "onPlugin-add"?: ((plugin: PluginInfo) => any) | undefined;
+    "onPlugin-create"?: ((type: "code" | "form", data: PluginCreationData) => any) | undefined;
+    "onTool-toggle"?: ((plugin: PluginInfo, toolId: string, enabled: boolean) => any) | undefined;
+    "onUpdate:activeCount"?: ((count: number) => any) | undefined;
+}>, {
+    title: string;
+    loading: boolean;
+    installedPlugins: PluginInfo[];
+    marketPlugins: PluginInfo[];
+    searchPlaceholder: string;
+    enableSearch: boolean;
+    installedSearchFn: (query: string, item: PluginInfo) => boolean;
+    marketSearchFn: (query: string, item: PluginInfo) => boolean;
+    marketCategoryOptions: import('./index.type').MarketCategoryOption[];
+    marketCategoryPlaceholder: string;
+    enableMarketCategoryFilter: boolean;
+    defaultActiveTab: "installed" | "market";
+    showInstalledTab: boolean;
+    showMarketTab: boolean;
+    popupConfig: PopupConfig;
+    installedTabTitle: string;
+    marketTabTitle: string;
+    showCustomAddButton: boolean;
+    customAddButtonText: string;
+    allowPluginToggle: boolean;
+    allowToolToggle: boolean;
+    allowPluginDelete: boolean;
+    allowPluginAdd: boolean;
+    marketLoading: boolean;
+}, {}, {}, {}, 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/prompts/index.d.ts

@@ -0,0 +1,12 @@
+import { App } from 'vue';
+import { default as PromptComp } from './prompt.vue';
+import { default as PromptsComp } from './prompts.vue';
+declare const installPrompt: <T>(app: App<T>) => void;
+export declare const Prompt: typeof PromptComp & {
+    install: typeof installPrompt;
+};
+declare const installPrompts: <T>(app: App<T>) => void;
+export declare const Prompts: typeof PromptsComp & {
+    install: typeof installPrompts;
+};
+export {};