@blueking/ai-ui-sdk 0.2.2 → 0.3.0-beta.2

package/dist/components/render-dialog/choose-resource.script.vue.js

@@ -0,0 +1,591 @@
+import { defineComponent as _defineComponent, createVNode as _createVNode2 } from 'vue';
+import { createVNode as _createVNode, unref as _unref, openBlock as _openBlock, createBlock as _createBlock, createCommentVNode as _createCommentVNode, resolveComponent as _resolveComponent, withCtx as _withCtx, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = {
+    class: "choose-resource g-position-relative"
+};
+import { ref, toRef, watch } from 'vue';
+import { MODULE_NAME } from '../../common/constants.ts.js';
+import RenderAgentSearch from '../render-agent/agent-search.vue.js';
+import RenderAgentCard from '../render-card/agent/index.vue.js';
+import RenderKnowledgeCard from '../render-card/knowledge/index.vue.js';
+import RenderKnowledgebaseCard from '../render-card/knowledgebase/index.vue.js';
+import RenderMcpCard from '../render-card/mcp/index.vue.js';
+import RenderPromptCard from '../render-card/prompt/index.vue.js';
+import RenderRoleCard from '../render-card/role/index.vue.js';
+import RenderSkillCard from '../render-card/skill/index.vue.js';
+import RenderToolCard from '../render-card/tool/index.vue.js';
+import RenderRoleSearch from '../render-collection/search/index.vue.js';
+import RenderKnowledgeSearch from '../render-knowledge/search/index.vue.js';
+import RenderKnowledgebaseSearch from '../render-knowledgebase/search/index.vue.js';
+import RenderMcpSearch from '../render-mcp/search/index.vue.js';
+import RenderPromptSearch from '../render-prompt/search/index.vue.js';
+import RenderSearchEmpty from '../render-search-empty/index.vue.js';
+import RenderSkillSearch from '../render-skill/search/index.vue.js';
+import RenderToolSearch from '../render-tool/search/index.vue.js';
+import { useAgentHttp } from '../../hooks/use-agent-http.ts.js';
+import { useCollectionHttp } from '../../hooks/use-collection-http.ts.js';
+import { useKnowledgeHttp } from '../../hooks/use-knowledge-http.ts.js';
+import { useMcpHttp } from '../../hooks/use-mcp-http.ts.js';
+import { usePromptHttp } from '../../hooks/use-prompt-http.ts.js';
+import { useScrollLoad } from '../../hooks/use-scroll-load.ts.js';
+import { useSkillHttp } from '../../hooks/use-skill-http.ts.js';
+import { useToolHttp } from '../../hooks/use-tool-http.ts.js';
+import { FileStatus, GroupType, KnowledgebaseType, Module, ResourceCardType } from '../../types/enum.ts.js';
+export default /*@__PURE__*/ _defineComponent({
+    props: {
+        choosenTools: {},
+        choosenMcps: {},
+        choosenKnowledges: {},
+        choosenKnowledgebases: {},
+        choosenAgents: {},
+        choosenRoles: {},
+        choosenPrompts: {},
+        choosenSpace: {},
+        choosenSkills: {},
+        module: {},
+        agentCode: {},
+        agentId: {},
+        canApply: {
+            type: Boolean
+        },
+        agentType: {},
+        createdBy: {},
+        multiple: {
+            type: Boolean
+        },
+        showTagSearch: {
+            type: Boolean
+        },
+        defaultModelId: {},
+        roleTypes: {},
+        spaceId: {},
+        memberUrl: {},
+        spaces: {},
+        apiPrefix: {}
+    },
+    emits: [
+        "update:choosenTools",
+        "update:choosenMcps",
+        "update:choosenKnowledges",
+        "update:choosenKnowledgebases",
+        "update:choosenAgents",
+        "update:choosenRoles",
+        "update:choosenPrompts",
+        "update:choosenSkills"
+    ],
+    setup (__props, { emit: __emit }) {
+        const props = __props;
+        const emits = __emit;
+        const { getAgentList } = useAgentHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getCollections } = useCollectionHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getKnowledgebases, getKnowledges } = useKnowledgeHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getMcpList } = useMcpHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getPrompts } = usePromptHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getSkillList } = useSkillHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getTools } = useToolHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const toolSearch = ref({});
+        const mcpSearch = ref({});
+        const knowledgeSearch = ref({});
+        const knowledgebaseSearch = ref({});
+        const agentSearch = ref({});
+        const promptSearch = ref({});
+        const roleSearch = ref({});
+        const skillSearch = ref({});
+        const tools = ref([]);
+        const mcps = ref([]);
+        const knowledges = ref([]);
+        const knowledgebases = ref([]);
+        const agents = ref([]);
+        const roles = ref([]);
+        const prompts = ref([]);
+        const skills = ref([]);
+        // 根据当前模块动态返回对应的搜索参数
+        const getCurrentSearch = ()=>{
+            switch(props.module){
+                case Module.Tool:
+                    return toolSearch.value;
+                case Module.Mcp:
+                    return mcpSearch.value;
+                case Module.Knowledge:
+                    return knowledgeSearch.value;
+                case Module.Knowledgebase:
+                    return knowledgebaseSearch.value;
+                case Module.Agent:
+                    return agentSearch.value;
+                case Module.Skill:
+                    return skillSearch.value;
+                case Module.Collection:
+                    return roleSearch.value;
+                case Module.Prompt:
+                    return promptSearch.value;
+                default:
+                    return {};
+            }
+        };
+        const handleGetResources = ({ page, pageSize })=>{
+            var _a;
+            const commonParams = {
+                groupType: GroupType.All,
+                spaceId: (_a = props.choosenSpace) === null || _a === void 0 ? void 0 : _a.spaceId,
+                canApply: props.canApply,
+                withPrivate: false,
+                createdBy: props.createdBy,
+                page,
+                pageSize
+            };
+            // 获取工具列表
+            if (props.module === Module.Tool) {
+                return getTools(Object.assign(Object.assign({}, commonParams), toolSearch.value));
+            }
+            // 获取mcp列表
+            if (props.module === Module.Mcp) {
+                return getMcpList(Object.assign(Object.assign(Object.assign({}, commonParams), mcpSearch.value), {
+                    agentCode: props.agentCode,
+                    withApigwMcp: !props.canApply
+                }));
+            }
+            // 获取知识列表
+            if (props.module === Module.Knowledge) {
+                return getKnowledges(Object.assign(Object.assign({}, commonParams), {
+                    searchbox: Object.assign({
+                        status: FileStatus.Uploaded
+                    }, knowledgeSearch.value),
+                    knowledgebaseType: KnowledgebaseType.IntentRecog,
+                    hiddenFolders: false
+                }));
+            }
+            // 获取知识库列表
+            if (props.module === Module.Knowledgebase) {
+                return getKnowledgebases(Object.assign(Object.assign({}, commonParams), knowledgebaseSearch.value));
+            }
+            // 获取agent列表
+            if (props.module === Module.Agent) {
+                return getAgentList(Object.assign(Object.assign(Object.assign({}, commonParams), agentSearch.value), {
+                    excludeAgentId: props.agentId,
+                    isPublished: true,
+                    agentType: props.agentType
+                }));
+            }
+            // 获取role列表
+            if (props.module === Module.Collection) {
+                return getCollections(Object.assign(Object.assign({}, commonParams), roleSearch.value));
+            }
+            // 获取prompt列表
+            if (props.module === Module.Prompt) {
+                return getPrompts(Object.assign(Object.assign({}, commonParams), promptSearch.value));
+            }
+            // 获取skill列表
+            if (props.module === Module.Skill) {
+                return getSkillList(Object.assign(Object.assign({}, commonParams), skillSearch.value));
+            }
+            return Promise.resolve({
+                results: [],
+                count: 0
+            });
+        };
+        const handleDataLoaded = (results, append)=>{
+            const moduleDataMap = {
+                [Module.Tool]: tools,
+                [Module.Mcp]: mcps,
+                [Module.Knowledge]: knowledges,
+                [Module.Knowledgebase]: knowledgebases,
+                [Module.Agent]: agents,
+                [Module.Collection]: roles,
+                [Module.Prompt]: prompts,
+                [Module.Skill]: skills
+            };
+            const target = moduleDataMap[props.module];
+            if (!target) return;
+            if (append) {
+                target.value.push(...results);
+            } else {
+                target.value = results;
+            }
+        };
+        const { isLoading: isLoadingResources, handleInitData } = useScrollLoad({
+            targetCls: '.resource-cards',
+            triggerApi: handleGetResources,
+            handleDataLoaded,
+            abort: ()=>{
+                getTools.abort();
+                getMcpList.abort();
+                getKnowledges.abort();
+                getKnowledgebases.abort();
+                getAgentList.abort();
+                getCollections.abort();
+                getPrompts.abort();
+                getSkillList.abort();
+            }
+        });
+        const RenderSearch = ()=>{
+            switch(props.module){
+                case Module.Tool:
+                    return _createVNode2(RenderToolSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Tool,
+                        "search": toolSearch.value,
+                        "onUpdate:search": (value)=>toolSearch.value = value,
+                        "memberUrl": props.memberUrl
+                    }, null);
+                case Module.Mcp:
+                    return _createVNode2(RenderMcpSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Mcp,
+                        "search": mcpSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "onUpdate:search": (value)=>mcpSearch.value = value
+                    }, null);
+                case Module.Knowledge:
+                    return _createVNode2(RenderKnowledgeSearch, {
+                        "search": knowledgeSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "apiPrefix": props.apiPrefix,
+                        "onUpdate:search": (value)=>knowledgeSearch.value = value
+                    }, null);
+                case Module.Knowledgebase:
+                    return _createVNode2(RenderKnowledgebaseSearch, {
+                        "search": knowledgebaseSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "apiPrefix": props.apiPrefix,
+                        "onUpdate:search": (value)=>knowledgebaseSearch.value = value
+                    }, null);
+                case Module.Agent:
+                    return _createVNode2(RenderAgentSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Agent,
+                        "search": agentSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "onUpdate:search": (value)=>agentSearch.value = value
+                    }, null);
+                case Module.Collection:
+                    return _createVNode2(RenderRoleSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Collection,
+                        "search": roleSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "onUpdate:search": (value)=>roleSearch.value = value
+                    }, null);
+                case Module.Prompt:
+                    return _createVNode2(RenderPromptSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Prompt,
+                        "search": promptSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "onUpdate:search": (value)=>promptSearch.value = value
+                    }, null);
+                case Module.Skill:
+                    return _createVNode2(RenderSkillSearch, {
+                        "isShowTagSearch": true,
+                        "apiPrefix": props.apiPrefix,
+                        "spaceId": props.spaceId,
+                        "module": Module.Skill,
+                        "search": skillSearch.value,
+                        "memberUrl": props.memberUrl,
+                        "onUpdate:search": (value)=>skillSearch.value = value
+                    }, null);
+            }
+        };
+        const RenderCards = ()=>{
+            switch(props.module){
+                case Module.Tool:
+                    return tools.value.map((tool)=>_createVNode2(RenderToolCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "tool": tool,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "checked": props.choosenTools.some((choosenTool)=>choosenTool.id === tool.id),
+                            "spaceId": tool.spaceId,
+                            "spaces": props.spaces,
+                            "apiPrefix": props.apiPrefix,
+                            "onChoose": ()=>handleToggleChooseTool(tool)
+                        }, null));
+                case Module.Mcp:
+                    return mcps.value.map((mcp)=>_createVNode2(RenderMcpCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "mcp": mcp,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "spaceId": mcp.spaceId,
+                            "spaces": props.spaces,
+                            "apiPrefix": props.apiPrefix,
+                            "checked": props.choosenMcps.some((choosenMcp)=>choosenMcp.id === mcp.id && choosenMcp.mcpType === mcp.mcpType),
+                            "onChoose": ()=>handleToggleChooseMcp(mcp)
+                        }, null));
+                case Module.Knowledge:
+                    return knowledges.value.map((knowledge)=>_createVNode2(RenderKnowledgeCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "knowledge": knowledge,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "apiPrefix": props.apiPrefix,
+                            "checked": props.choosenKnowledges.some((chooseKnowledge)=>chooseKnowledge.id === knowledge.id),
+                            "onChoose": ()=>handleToggleChooseKnowledge(knowledge)
+                        }, null));
+                case Module.Knowledgebase:
+                    return knowledgebases.value.map((knowledgebase)=>_createVNode2(RenderKnowledgebaseCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "knowledgebase": knowledgebase,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "spaceId": knowledgebase.spaceId,
+                            "spaces": props.spaces,
+                            "apiPrefix": props.apiPrefix,
+                            "checked": props.choosenKnowledgebases.some((chooseKnowledgebase)=>chooseKnowledgebase.id === knowledgebase.id),
+                            "onChoose": ()=>handleToggleChooseKnowledgebase(knowledgebase)
+                        }, null));
+                case Module.Agent:
+                    return agents.value.map((agent)=>_createVNode2(RenderAgentCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "agent": agent,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "checked": props.choosenAgents.some((choosenAgent)=>choosenAgent.id === agent.id),
+                            "spaceId": agent.spaceId,
+                            "spaces": props.spaces,
+                            "apiPrefix": props.apiPrefix,
+                            "onChoose": ()=>handleToggleChooseAgent(agent)
+                        }, null));
+                case Module.Collection:
+                    return roles.value.map((role)=>_createVNode2(RenderRoleCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "role": role,
+                            "isShowCheckbox": true,
+                            "multiple": false,
+                            "checked": props.choosenRoles.some((choosenRole)=>choosenRole.id === role.id),
+                            "onChoose": ()=>handleToggleChooseRole(role),
+                            "defaultModelId": props.defaultModelId,
+                            "spaceId": role.spaceId,
+                            "spaces": props.spaces,
+                            "roleTypes": props.roleTypes,
+                            "apiPrefix": props.apiPrefix
+                        }, null));
+                case Module.Prompt:
+                    return prompts.value.map((prompt)=>_createVNode2(RenderPromptCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "prompt": prompt,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "spaceId": prompt.spaceId,
+                            "spaces": props.spaces,
+                            "defaultModelId": props.defaultModelId,
+                            "apiPrefix": props.apiPrefix,
+                            "checked": props.choosenPrompts.some((choosenPrompt)=>choosenPrompt.id === prompt.id),
+                            "onChoose": ()=>handleToggleChoosePrompt(prompt)
+                        }, null));
+                case Module.Skill:
+                    return skills.value.map((skill)=>_createVNode2(RenderSkillCard, {
+                            "class": "g-mb-12",
+                            "type": ResourceCardType.Choose,
+                            "skill": skill,
+                            "isShowCheckbox": true,
+                            "multiple": true,
+                            "checked": props.choosenSkills.some((choosenSkill)=>choosenSkill.id === skill.id),
+                            "spaceId": skill.spaceId,
+                            "spaces": props.spaces,
+                            "apiPrefix": props.apiPrefix,
+                            "onChoose": ()=>handleToggleChooseSkill(skill)
+                        }, null));
+            }
+        };
+        const updateSearch = ()=>{
+            if (props.module === Module.Tool) {
+                toolSearch.value = {};
+            }
+            if (props.module === Module.Mcp) {
+                mcpSearch.value = {};
+            }
+            if (props.module === Module.Knowledge) {
+                knowledgeSearch.value = {};
+            }
+            if (props.module === Module.Knowledgebase) {
+                knowledgebaseSearch.value = {};
+            }
+            if (props.module === Module.Agent) {
+                agentSearch.value = {};
+            }
+            if (props.module === Module.Skill) {
+                skillSearch.value = {};
+            }
+        };
+        const getIsEmpty = ()=>{
+            if (props.module === Module.Tool) {
+                return tools.value.length <= 0;
+            }
+            if (props.module === Module.Mcp) {
+                return mcps.value.length <= 0;
+            }
+            if (props.module === Module.Knowledge) {
+                return knowledges.value.length <= 0;
+            }
+            if (props.module === Module.Knowledgebase) {
+                return knowledgebases.value.length <= 0;
+            }
+            if (props.module === Module.Agent) {
+                return agents.value.length <= 0;
+            }
+            if (props.module === Module.Collection) {
+                return roles.value.length <= 0;
+            }
+            if (props.module === Module.Prompt) {
+                return prompts.value.length <= 0;
+            }
+            if (props.module === Module.Skill) {
+                return skills.value.length <= 0;
+            }
+        };
+        const getDescription = ()=>{
+            return `暂无${props.canApply ? '可申请的' : ''}${MODULE_NAME[props.module]}`;
+        };
+        // tools
+        const handleToggleChooseTool = (tool)=>{
+            if (props.choosenTools.some((choosenTool)=>choosenTool.id === tool.id)) {
+                emits('update:choosenTools', props.choosenTools.filter((choosenTool)=>choosenTool.id !== tool.id));
+            } else {
+                emits('update:choosenTools', [
+                    ...props.choosenTools,
+                    tool
+                ]);
+            }
+        };
+        // mcps
+        const handleToggleChooseMcp = (mcp)=>{
+            if (props.choosenMcps.some((choosenMcp)=>choosenMcp.id === mcp.id && choosenMcp.mcpType === mcp.mcpType)) {
+                emits('update:choosenMcps', props.choosenMcps.filter((choosenMcps)=>!(choosenMcps.id === mcp.id && choosenMcps.mcpType === mcp.mcpType)));
+            } else {
+                emits('update:choosenMcps', [
+                    ...props.choosenMcps,
+                    mcp
+                ]);
+            }
+        };
+        // knowledges
+        const handleToggleChooseKnowledge = (knowledge)=>{
+            if (props.choosenKnowledges.some((choosenKnowledge)=>choosenKnowledge.id === knowledge.id)) {
+                emits('update:choosenKnowledges', props.choosenKnowledges.filter((choosenKnowledge)=>choosenKnowledge.id !== knowledge.id));
+            } else {
+                emits('update:choosenKnowledges', [
+                    knowledge
+                ]);
+            }
+        };
+        // knowledgebases
+        const handleToggleChooseKnowledgebase = (knowledgebase)=>{
+            if (props.choosenKnowledgebases.some((choosenKnowledgebase)=>choosenKnowledgebase.id === knowledgebase.id)) {
+                emits('update:choosenKnowledgebases', props.choosenKnowledgebases.filter((choosenKnowledgebase)=>choosenKnowledgebase.id !== knowledgebase.id));
+            } else {
+                emits('update:choosenKnowledgebases', [
+                    ...props.choosenKnowledgebases,
+                    knowledgebase
+                ]);
+            }
+        };
+        // agents
+        const handleToggleChooseAgent = (agent)=>{
+            if (props.choosenAgents.some((choosenAgent)=>choosenAgent.id === agent.id)) {
+                emits('update:choosenAgents', props.choosenAgents.filter((choosenAgent)=>choosenAgent.id !== agent.id));
+            } else {
+                emits('update:choosenAgents', [
+                    ...props.choosenAgents,
+                    agent
+                ]);
+            }
+        };
+        // roles
+        const handleToggleChooseRole = (role)=>{
+            if (props.choosenRoles.some((choosenRole)=>choosenRole.id === role.id)) {
+                emits('update:choosenRoles', props.choosenRoles.filter((choosenRole)=>choosenRole.id !== role.id));
+            } else {
+                emits('update:choosenRoles', props.multiple === false ? [
+                    role
+                ] : [
+                    ...props.choosenRoles,
+                    role
+                ]);
+            }
+        };
+        // prompts
+        const handleToggleChoosePrompt = (prompt)=>{
+            if (props.choosenPrompts.some((choosenPrompt)=>choosenPrompt.id === prompt.id)) {
+                emits('update:choosenPrompts', props.choosenPrompts.filter((choosenPrompt)=>choosenPrompt.id !== prompt.id));
+            } else {
+                emits('update:choosenPrompts', [
+                    ...props.choosenPrompts,
+                    prompt
+                ]);
+            }
+        };
+        // skills
+        const handleToggleChooseSkill = (skill)=>{
+            if (props.choosenSkills.some((choosenSkill)=>choosenSkill.id === skill.id)) {
+                emits('update:choosenSkills', props.choosenSkills.filter((choosenSkill)=>choosenSkill.id !== skill.id));
+            } else {
+                emits('update:choosenSkills', [
+                    ...props.choosenSkills,
+                    skill
+                ]);
+            }
+        };
+        watch([
+            ()=>props.choosenSpace,
+            ()=>props.module,
+            ()=>toolSearch.value,
+            ()=>mcpSearch.value,
+            ()=>knowledgeSearch.value,
+            ()=>knowledgebaseSearch.value,
+            ()=>agentSearch.value,
+            ()=>roleSearch.value,
+            ()=>promptSearch.value,
+            ()=>skillSearch.value,
+            ()=>props.spaceId,
+            ()=>props.createdBy
+        ], handleInitData, {
+            immediate: true
+        });
+        return (_ctx, _cache)=>{
+            const _component_bk_loading = _resolveComponent("bk-loading");
+            return _openBlock(), _createElementBlock("section", _hoisted_1, [
+                _createVNode(RenderSearch, {
+                    class: "g-mb-12"
+                }),
+                _createVNode(_component_bk_loading, {
+                    loading: _unref(isLoadingResources),
+                    class: "resource-cards g-scrollbar"
+                }, {
+                    default: _withCtx(()=>[
+                            _createVNode(RenderCards),
+                            getIsEmpty() ? (_openBlock(), _createBlock(RenderSearchEmpty, {
+                                key: 0,
+                                scene: "part",
+                                search: getCurrentSearch(),
+                                description: getDescription(),
+                                "onUpdate:search": updateSearch
+                            }, null, 8 /* PROPS */ , [
+                                "search",
+                                "description"
+                            ])) : _createCommentVNode("v-if", true)
+                        ]),
+                    _: 1 /* STABLE */ 
+                }, 8 /* PROPS */ , [
+                    "loading"
+                ])
+            ]);
+        };
+    }
+});

package/dist/components/render-dialog/choose-resource.vue.css

@@ -0,0 +1,8 @@
+
+.choose-resource[data-v-sd027sa2] {
+  height: 100%;
+  padding: 0 16px;
+}
+.choose-resource .resource-cards[data-v-sd027sa2] {
+    max-height: calc(100% - 44px);
+}

package/dist/components/render-dialog/choose-resource.vue.d.ts

@@ -0,0 +1,56 @@
+import type { ILLMPromptRole } from '@/types';
+import type { IAgent } from '@/types/agent';
+import type { ICollection } from '@/types/collection';
+import { AgentType, Module } from '@/types/enum';
+import type { IKnowledge, IKnowledgebase } from '@/types/knowledge';
+import type { IMcp } from '@/types/mcp';
+import type { IPrompt } from '@/types/prompt';
+import type { ISkill } from '@/types/skill';
+import type { ISpace, IUsableSpace } from '@/types/space';
+import type { ITool } from '@/types/tool';
+interface IProps {
+    choosenTools?: ITool[];
+    choosenMcps?: IMcp[];
+    choosenKnowledges?: IKnowledge[];
+    choosenKnowledgebases?: IKnowledgebase[];
+    choosenAgents?: IAgent[];
+    choosenRoles?: ICollection[];
+    choosenPrompts?: IPrompt[];
+    choosenSpace?: IUsableSpace;
+    choosenSkills?: ISkill[];
+    module: Module;
+    agentCode?: string;
+    agentId: number;
+    canApply?: boolean;
+    agentType?: AgentType;
+    createdBy?: string;
+    multiple?: boolean;
+    showTagSearch?: boolean;
+    defaultModelId: string;
+    roleTypes: ILLMPromptRole[];
+    spaceId?: string;
+    memberUrl: string;
+    spaces?: ISpace[];
+    apiPrefix: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<IProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:choosenTools": (value: ITool[]) => any;
+    "update:choosenMcps": (value: IMcp[]) => any;
+    "update:choosenKnowledges": (value: IKnowledge[]) => any;
+    "update:choosenKnowledgebases": (value: IKnowledgebase[]) => any;
+    "update:choosenAgents": (value: IAgent[]) => any;
+    "update:choosenRoles": (value: ICollection[]) => any;
+    "update:choosenPrompts": (value: IPrompt[]) => any;
+    "update:choosenSkills": (value: ISkill[]) => any;
+}, string, import("vue").PublicProps, Readonly<IProps> & Readonly<{
+    "onUpdate:choosenTools"?: (value: ITool[]) => any;
+    "onUpdate:choosenMcps"?: (value: IMcp[]) => any;
+    "onUpdate:choosenKnowledges"?: (value: IKnowledge[]) => any;
+    "onUpdate:choosenKnowledgebases"?: (value: IKnowledgebase[]) => any;
+    "onUpdate:choosenAgents"?: (value: IAgent[]) => any;
+    "onUpdate:choosenRoles"?: (value: ICollection[]) => any;
+    "onUpdate:choosenPrompts"?: (value: IPrompt[]) => any;
+    "onUpdate:choosenSkills"?: (value: ISkill[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/render-dialog/choose-resource.vue.js

@@ -0,0 +1,5 @@
+import script from './choose-resource.script.vue.js';
+script.__scopeId = "data-v-sd027sa2";
+script.__file = "./src/components/render-dialog/choose-resource.vue";
+import './choose-resource.vue.css';
+export default script;