@aigne/core 0.0.1

package/lib/cjs/assistant/generate-output.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadataStreamOutputFormatPrompt = exports.metadataOutputFormatPrompt = exports.metadataSuffix = exports.metadataPrefix = void 0;
+exports.generateOutput = generateOutput;
+exports.extractMetadataFromStream = extractMetadataFromStream;
+const web_1 = require("stream/web");
+const chat_1 = require("@blocklet/ai-kit/api/types/chat");
+const schema_1 = require("../types/runtime/schema");
+const extract_metadata_transform_1 = require("../utils/extract-metadata-transform");
+const retry_1 = __importDefault(require("../utils/retry"));
+exports.metadataPrefix = '```metadata';
+exports.metadataSuffix = '```';
+const metadataOutputFormatPrompt = (schema) => `\
+## Metadata Schema
+Here is the metadata json schema, inside the <metadata-schema></metadata-schema> XML tags:
+<metadata-schema>
+${schema}
+</metadata-schema>
+
+## Output Rules
+- You have to generate a json metadata base on the metadata schema above, inside the <metadata-schema></metadata-schema> XML tags
+- Don't make any explanation
+
+## Output Format
+[Generate a json data based on the above metadata schema, put the json string into the following code block]
+${exports.metadataPrefix}
+${exports.metadataSuffix}
+
+## Output Example
+${exports.metadataPrefix}
+{"key": "value"}
+${exports.metadataSuffix}
+`;
+exports.metadataOutputFormatPrompt = metadataOutputFormatPrompt;
+const metadataStreamOutputFormatPrompt = (schema) => `\
+## Metadata Schema
+Here is the metadata json schema, inside the <metadata-schema></metadata-schema> XML tags:
+<metadata-schema>
+${schema}
+</metadata-schema>
+
+## Output Rules
+- You have to generate a text content and a json metadata base on the metadata schema above, inside the <metadata-schema></metadata-schema> XML tags
+- Don't make any explanation
+
+## Output Format
+[Your text content here]
+[Generate a json data based on the above metadata schema, put the json string into the following code block]
+${exports.metadataPrefix}
+${exports.metadataSuffix}
+
+## Output Example
+[Here is your answer to the the user's question]
+${exports.metadataPrefix}
+{"key": "value"}
+${exports.metadataSuffix}
+`;
+exports.metadataStreamOutputFormatPrompt = metadataStreamOutputFormatPrompt;
+async function generateOutput({ assistant, messages, callAI, maxRetries = 0, datastoreVariables, }) {
+    const jsonSchema = (0, schema_1.outputVariablesToJsonSchema)(assistant, { variables: datastoreVariables });
+    const joiSchema = (0, schema_1.outputVariablesToJoiSchema)(assistant, { variables: datastoreVariables });
+    const outputSchema = JSON.stringify(jsonSchema, null, 2);
+    messages.push({
+        role: 'system',
+        content: (0, exports.metadataOutputFormatPrompt)(outputSchema),
+    });
+    return (0, retry_1.default)(async () => {
+        const result = await callAI({
+            assistant,
+            input: {
+                stream: true,
+                messages,
+            },
+        });
+        let text = '';
+        for await (const chunk of extractMetadataFromStream(result, true)) {
+            if (chunk.type === 'match')
+                text += chunk.text;
+        }
+        const json = JSON.parse(text);
+        return await joiSchema.validateAsync(json);
+    }, maxRetries);
+}
+function extractMetadataFromStream(input, extract = true) {
+    return input
+        .pipeThrough(new web_1.TransformStream({
+        transform: (chunk, controller) => {
+            if ((0, chat_1.isChatCompletionChunk)(chunk))
+                if (chunk.delta.content)
+                    controller.enqueue(chunk.delta.content);
+        },
+    }))
+        .pipeThrough(new extract_metadata_transform_1.ExtractMetadataTransform({
+        // Pass empty string to disable extractor
+        start: extract ? exports.metadataPrefix : '',
+        end: extract ? exports.metadataSuffix : '',
+    }));
+}

package/lib/cjs/assistant/select-agent.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chat_1 = require("@blocklet/ai-kit/api/types/chat");
+const retry_1 = __importDefault(require("../utils/retry"));
+const selectAgentSystemPrompt = () => `\
+### Job Description
+You are a text classification engine that analyzes text data and assigns categories based on user input or automatically determined categories.
+
+
+### Task
+Your task is to assign one categories ONLY to the input text and only one category may be assigned returned in the output.
+Additionally, you need to extract the key words from the text that are related to the classification.
+
+
+### Format
+- "input_text" is in the variable text_field.
+- "categories" are specified as a category list in the variable categories or left empty for automatic determination.
+- "classification_instructions" may be included to improve the classification accuracy.
+
+
+### Constraint
+- DO NOT include anything other than the JSON array in your response.
+- The output results must be within the scope of categories, not content outside the scope
+`;
+async function generateSelectAgentName({ assistant, message, callAI, maxRetries = 0, categories, }) {
+    return (0, retry_1.default)(async () => {
+        const selectAgentIdResponseByPrompt = await callAI({
+            assistant,
+            input: {
+                messages: [
+                    {
+                        role: 'system',
+                        content: `${selectAgentSystemPrompt()}`,
+                    },
+                    {
+                        role: 'user',
+                        content: '\n { "input_text": ["I recently had a great experience with your company. The service was prompt and the staff was very friendly."],\n "categories": [{,"category_name": "Customer Service"}, {"category_name": "Satisfaction"}, {"category_name": "Sales"}, {"category_name": "Product"}],\n "classification_instructions": []}\n',
+                    },
+                    {
+                        role: 'assistant',
+                        content: '{"category_name": "Customer Service"}',
+                    },
+                    {
+                        role: 'user',
+                        content: '\n {"input_text": ["bad service, slow to bring the food"],\n "categories": [{"category_name": "Food Quality"}, {"category_name": "Experience"}, {"category_name": "Price"}],\n "classification_instructions": []}\n',
+                    },
+                    {
+                        role: 'assistant',
+                        content: '{"category_name": "Experience"}',
+                    },
+                    {
+                        role: 'user',
+                        content: `\n {"input_text": [${message}],\n "categories": [${categories}],\n "classification_instructions": []}\n`,
+                    },
+                ],
+                model: assistant?.model,
+                temperature: assistant?.temperature,
+                topP: assistant?.topP,
+                presencePenalty: assistant?.presencePenalty,
+                frequencyPenalty: assistant?.frequencyPenalty,
+            },
+        });
+        let text = '';
+        for await (const chunk of selectAgentIdResponseByPrompt) {
+            if ((0, chat_1.isChatCompletionChunk)(chunk) && chunk.delta.content) {
+                text += chunk.delta.content;
+            }
+        }
+        const json = JSON.parse(text);
+        return json;
+    }, maxRetries);
+}
+exports.default = generateSelectAgentName;

package/lib/cjs/assistant/type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCompletionDirective = void 0;
+class ToolCompletionDirective extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
+}
+exports.ToolCompletionDirective = ToolCompletionDirective;

package/lib/cjs/common/aid.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdentity = parseIdentity;
+exports.stringifyIdentity = stringifyIdentity;
+const js_base64_1 = require("js-base64");
+function parseIdentity(aid, options) {
+    let blockletDid;
+    let projectId;
+    let projectRef;
+    let agentId;
+    try {
+        const s = js_base64_1.Base64.decode(aid).split('/');
+        if (s.length === 4) {
+            [blockletDid, projectId, projectRef, agentId] = s;
+        }
+        else if (s.length === 3) {
+            [projectId, projectRef, agentId] = s;
+        }
+        else if (s.length === 2) {
+            [projectId, agentId] = s;
+        }
+    }
+    catch (error) {
+        console.error('parse assistantId error', { error });
+    }
+    if (projectId && agentId)
+        return {
+            blockletDid: blockletDid || undefined,
+            projectId,
+            projectRef: projectRef || undefined,
+            agentId,
+        };
+    if (options?.rejectWhenError)
+        throw new Error(`Invalid assistant identity ${aid}`);
+    return undefined;
+}
+function stringifyIdentity({ blockletDid, projectId, projectRef, agentId, }) {
+    if (typeof projectId !== 'string' || typeof agentId !== 'string') {
+        throw new Error('Invalid aid fragments');
+    }
+    return js_base64_1.Base64.encodeURI([blockletDid || '', projectId, projectRef || '', agentId].join('/'));
+}

package/lib/cjs/common/index.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultImageModel = exports.supportJsonSchemaModels = exports.defaultTextModel = void 0;
+exports.getSupportedModels = getSupportedModels;
+exports.getSupportedImagesModels = getSupportedImagesModels;
+exports.getServiceModePermissionMap = getServiceModePermissionMap;
+exports.defaultTextModel = 'gpt-4o-mini';
+exports.supportJsonSchemaModels = ['gpt-4o', 'gpt-4o-mini'];
+async function getSupportedModels() {
+    return [
+        {
+            brand: 'OpenAI',
+            model: 'gpt-4o',
+            name: 'GPT4o',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 128000,
+            maxTokensDefault: 128000,
+        },
+        {
+            brand: 'OpenAI',
+            model: 'gpt-4o-mini',
+            name: 'GPT4o mini',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 128000,
+            maxTokensDefault: 128000,
+        },
+        {
+            brand: 'OpenAI',
+            model: 'gpt-3.5-turbo',
+            name: 'GPT3.5 turbo',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 4096,
+            maxTokensDefault: 4096,
+        },
+        {
+            brand: 'OpenAI',
+            model: 'gpt-3.5-turbo-16k',
+            name: 'GPT3.5 turbo 16k',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 16385,
+            maxTokensDefault: 16385,
+        },
+        {
+            brand: 'OpenAI',
+            model: 'gpt-4',
+            name: 'GPT4',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 8192,
+            maxTokensDefault: 8192,
+        },
+        {
+            brand: 'OpenAI',
+            model: 'gpt-4-32k',
+            name: 'GPT4 32k',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            presencePenaltyMin: -2,
+            presencePenaltyMax: 2,
+            presencePenaltyDefault: 0,
+            frequencyPenaltyMin: -2,
+            frequencyPenaltyMax: 2,
+            frequencyPenaltyDefault: 0,
+            maxTokensMin: 1,
+            maxTokensMax: 32768,
+            maxTokensDefault: 32768,
+        },
+        {
+            brand: 'Google',
+            model: 'gemini-pro',
+            name: 'Gemini Pro',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0.1,
+            topPMax: 1,
+            topPDefault: 1,
+            maxTokensMin: 1,
+            maxTokensMax: 2048,
+            maxTokensDefault: 2048,
+        },
+        {
+            brand: 'Mistral AI',
+            model: 'openRouter/mistralai/mistral-7b-instruct',
+            name: 'Mistral 7B Instruct',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            maxTokensMin: 1,
+            maxTokensMax: 8192,
+            maxTokensDefault: 8192,
+        },
+        {
+            brand: 'Mistral AI',
+            model: 'openRouter/mistralai/mixtral-8x7b-instruct',
+            name: 'Mixtral 8x7B Instruct (beta)',
+            temperatureMin: 0,
+            temperatureMax: 2,
+            temperatureDefault: 1,
+            topPMin: 0,
+            topPMax: 1,
+            topPDefault: 1,
+            maxTokensMin: 1,
+            maxTokensMax: 32768,
+            maxTokensDefault: 32768,
+        },
+        {
+            brand: 'Hugging Face',
+            model: 'Hugging Face',
+            disabled: true,
+        },
+        {
+            brand: 'Azure OpenAI',
+            model: 'Azure OpenAI',
+            disabled: true,
+        },
+        {
+            brand: 'Replicate',
+            model: 'Replicate',
+            disabled: true,
+        },
+        {
+            brand: 'Vertex AI',
+            model: 'Vertex AI',
+            disabled: true,
+        },
+    ];
+}
+exports.defaultImageModel = 'dall-e-2';
+async function getSupportedImagesModels() {
+    return [
+        {
+            brand: 'OpenAI',
+            model: 'dall-e-2',
+            nMin: 1,
+            nMax: 10,
+            nDefault: 1,
+            size: ['256x256', '512x512', '1024x1024'],
+            sizeDefault: '256x256',
+        },
+        {
+            brand: 'OpenAI',
+            model: 'dall-e-3',
+            nMin: 1,
+            nMax: 1,
+            nDefault: 1,
+            quality: ['standard', 'hd'],
+            qualityDefault: 'standard',
+            size: ['1024x1024', '1792x1024', '1024x1792'],
+            sizeDefault: '1024x1024',
+            style: ['vivid', 'natural'],
+            styleDefault: 'vivid',
+        },
+    ];
+}
+function getServiceModePermissionMap(serviceMode) {
+    const permissionMap = {
+        single: {
+            ensureViewAllProjectsRoles: ['owner', 'admin', 'promptsEditor'],
+            ensurePromptsEditorRoles: ['owner', 'admin', 'promptsEditor'],
+            ensurePromptsAdminRoles: ['owner', 'admin', 'promptsEditor'],
+        },
+        multiple: {
+            ensureViewAllProjectsRoles: [],
+            // no need to check, everyone can do it, will check author permission in the backend
+            ensurePromptsEditorRoles: undefined,
+            ensurePromptsAdminRoles: ['owner', 'admin', 'promptsEditor'],
+        },
+    };
+    // try to fallback to 'single-tenant'
+    return permissionMap[serviceMode] || permissionMap.single;
+}

package/lib/cjs/common/resource-manager.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceManager = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const component_1 = require("@blocklet/sdk/lib/component");
+const config_1 = __importDefault(require("@blocklet/sdk/lib/config"));
+const fs_extra_1 = require("fs-extra");
+const lodash_1 = require("lodash");
+const yaml_1 = require("yaml");
+const constants_1 = require("../constants");
+const logger_1 = __importDefault(require("../logger"));
+const types_1 = require("../types");
+const is_non_nullable_1 = require("../utils/is-non-nullable");
+const getResourceList = () => {
+    return types_1.ResourceTypes.flatMap((type) => (0, component_1.getResources)({ types: [{ did: constants_1.AIGNE_STUDIO_COMPONENT_DID, type }], skipRunningCheck: true }).map((i) => ({
+        ...i,
+        type,
+    }))).filter((0, is_non_nullable_1.isPropsNonNullable)('path'));
+};
+async function loadProjectsFromResourceBlockletDir({ did, path, }) {
+    if (!(await (0, fs_extra_1.exists)(path)))
+        return [];
+    const projectYamlPaths = (await (0, promises_1.readdir)(path)).map((filename) => (0, path_1.join)(path, filename, `${filename}.yaml`));
+    return (await Promise.all(projectYamlPaths.map(async (filepath) => {
+        try {
+            const project = await (0, types_1.validateResourceProject)((0, yaml_1.parse)((await (0, promises_1.readFile)(filepath)).toString()));
+            return {
+                ...project,
+                blocklet: { did },
+                dir: (0, path_1.dirname)(filepath),
+                agentMap: Object.fromEntries(project.agents.map((i) => [i.id, i])),
+            };
+        }
+        catch (error) {
+            logger_1.default.error('parse aigne project resource file error', { error });
+            return null;
+        }
+    }))).filter(is_non_nullable_1.isNonNullable);
+}
+const loadResourceKnowledge = async () => {
+    const dirs = getResourceList().filter((i) => i.type === 'knowledge');
+    if (dirs.length === 0)
+        return [];
+    return (await Promise.all(dirs.map(async (item) => {
+        try {
+            if (!(await (0, fs_extra_1.exists)(item.path)))
+                return undefined;
+            const knowledgeIds = await (0, promises_1.readdir)(item.path);
+            if (!knowledgeIds.length)
+                return undefined;
+            return await Promise.all(knowledgeIds.map(async (knowledgeId) => {
+                try {
+                    const knowledgePath = (0, path_1.join)(item.path, knowledgeId);
+                    const vectorsPath = (0, path_1.join)(knowledgePath, 'vectors');
+                    const uploadPath = (0, path_1.join)(knowledgePath, 'uploads');
+                    const sourcesPath = (0, path_1.join)(knowledgePath, 'sources');
+                    const processedPath = (0, path_1.join)(knowledgePath, 'processed');
+                    const logoPath = (0, path_1.join)(knowledgePath, 'logo.png');
+                    const knowledgeJsonPath = (0, path_1.join)(knowledgePath, 'knowledge.yaml');
+                    const knowledge = (0, yaml_1.parse)((await (0, promises_1.readFile)(knowledgeJsonPath)).toString());
+                    const documentsPath = (0, path_1.join)(knowledgePath, 'documents.yaml');
+                    const documents = (0, yaml_1.parse)((await (0, promises_1.readFile)(documentsPath)).toString());
+                    const contentsPath = (0, path_1.join)(knowledgePath, 'contents.yaml');
+                    const contents = (await (0, fs_extra_1.exists)(contentsPath)) ? (0, yaml_1.parse)((await (0, promises_1.readFile)(contentsPath)).toString()) : [];
+                    const segmentsPath = (0, path_1.join)(knowledgePath, 'segments.yaml');
+                    const segments = (await (0, fs_extra_1.exists)(segmentsPath)) ? (0, yaml_1.parse)((await (0, promises_1.readFile)(segmentsPath)).toString()) : [];
+                    return {
+                        title: item.title,
+                        did: item.did,
+                        knowledge: { projectId: knowledge.appId, ...knowledge },
+                        documents,
+                        segments,
+                        contents,
+                        blockletDid: item.did,
+                        vectorsPath,
+                        uploadPath, // old source
+                        sourcesPath, // new source
+                        processedPath,
+                        logoPath,
+                    };
+                }
+                catch (error) {
+                    logger_1.default.error('read knowledge resource error', { error });
+                }
+                return undefined;
+            }));
+        }
+        catch (error) {
+            logger_1.default.error('read knowledge resource error', { error });
+        }
+        return undefined;
+    })))
+        .flat()
+        .filter(is_non_nullable_1.isNonNullable);
+};
+async function loadResources() {
+    const list = getResourceList().filter((i) => i.type !== 'knowledge');
+    const resources = (0, lodash_1.groupBy)(await Promise.all(list.map(async (item) => ({ ...item, projects: await loadProjectsFromResourceBlockletDir(item) }))), (i) => i.type);
+    const knowledgeList = await loadResourceKnowledge();
+    return {
+        knowledge: {
+            knowledgeList,
+            blockletMap: Object.fromEntries(Object.entries((0, lodash_1.groupBy)(knowledgeList, (i) => i.blockletDid)).map(([blockletDid, kbs]) => [
+                blockletDid,
+                { knowledgeMap: Object.fromEntries(kbs.map((i) => [i.knowledge.id, i])) },
+            ])),
+        },
+        agents: Object.fromEntries(Object.entries(resources).map(([type, group]) => {
+            const blocklets = Object.entries((0, lodash_1.groupBy)(group.flatMap((i) => i.projects), (i) => i.blocklet.did)).map(([blockletDid, projects]) => ({
+                did: blockletDid,
+                status: group[0].status,
+                projectMap: Object.fromEntries(projects.map((i) => [i.project.id, i])),
+            }));
+            return [
+                type,
+                {
+                    projects: group.flatMap((i) => i.projects),
+                    blockletMap: Object.fromEntries(blocklets.map((i) => [i.did, i])),
+                },
+            ];
+        })),
+    };
+}
+class ResourceManager {
+    constructor({ wait = 5000, watch = true } = {}) {
+        if (watch) {
+            const reload = (0, lodash_1.throttle)(async () => {
+                logger_1.default.info('reload resource states');
+                await this.reload()
+                    .then((resource) => {
+                    logger_1.default.info('reload resource states success', {
+                        projects: Object.values(resource.agents).reduce((res, i) => i.projects.length + res, 0),
+                        knowledge: resource.knowledge.knowledgeList.length,
+                    });
+                })
+                    .catch((error) => {
+                    logger_1.default.error('reload resource states error', { error });
+                });
+            }, wait, { leading: false, trailing: true });
+            config_1.default.events.on(config_1.default.Events.componentAdded, reload);
+            config_1.default.events.on(config_1.default.Events.componentRemoved, reload);
+            config_1.default.events.on(config_1.default.Events.componentStarted, reload);
+            config_1.default.events.on(config_1.default.Events.componentStopped, reload);
+            config_1.default.events.on(config_1.default.Events.componentUpdated, reload);
+        }
+    }
+    promise;
+    get resources() {
+        if (!this.promise) {
+            this.promise = loadResources();
+        }
+        return this.promise;
+    }
+    async reload() {
+        this.promise = loadResources();
+        return this.resources;
+    }
+    async getProjects({ blockletDid, type }) {
+        const resources = await this.resources;
+        const list = resources.agents[type]?.projects ?? [];
+        if (blockletDid) {
+            return list.filter((i) => i.blocklet.did === blockletDid);
+        }
+        return list;
+    }
+    async getProject({ blockletDid, projectId, type, }) {
+        const resources = await this.resources;
+        for (const t of type ? [type].flat() : types_1.ResourceTypes) {
+            const p = resources.agents[t]?.blockletMap[blockletDid]?.projectMap[projectId];
+            if (p)
+                return p;
+        }
+        return undefined;
+    }
+    async getAgent({ blockletDid, projectId, agentId, type = types_1.ResourceTypes, }) {
+        const resources = await this.resources;
+        for (const t of [type].flat()) {
+            const blocklet = resources.agents[t]?.blockletMap[blockletDid];
+            const project = blocklet?.projectMap[projectId];
+            const agent = project?.agentMap[agentId];
+            if (agent)
+                return { agent, project: project.project, blocklet: { did: blockletDid } };
+        }
+        return undefined;
+    }
+    async getKnowledgeList() {
+        const resources = await this.resources;
+        return resources.knowledge.knowledgeList;
+    }
+    async getKnowledge({ blockletDid, knowledgeId }) {
+        const resources = await this.resources;
+        return resources.knowledge.blockletMap[blockletDid]?.knowledgeMap[knowledgeId];
+    }
+}
+exports.ResourceManager = ResourceManager;

package/lib/cjs/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIGNE_ISSUE_VC_PREFIX = exports.NFT_BLENDER_COMPONENT_DID = exports.AIGNE_STUDIO_COMPONENT_DID = exports.AIGNE_RUNTIME_CUSTOM_COMPONENT_ID = exports.AIGNE_COMPONENTS_COMPONENT_DID = exports.AIGNE_RUNTIME_COMPONENT_DID = void 0;
+exports.AIGNE_RUNTIME_COMPONENT_DID = 'z2qaBP9SahqU2L2YA3ip7NecwKACMByTFuiJ2';
+exports.AIGNE_COMPONENTS_COMPONENT_DID = 'z2qa6fvjmjew4pWJyTsKaWFuNoMUMyXDh5A1D';
+exports.AIGNE_RUNTIME_CUSTOM_COMPONENT_ID = 'grc9q1cveub6pnl8';
+exports.AIGNE_STUDIO_COMPONENT_DID = 'z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB';
+exports.NFT_BLENDER_COMPONENT_DID = 'z8ia1ieY5KhEC4LMRETzS5nUwD7PvAND8qkfX';
+exports.AIGNE_ISSUE_VC_PREFIX = 'AIGNE';