@aigne/core 0.0.1

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

@@ -0,0 +1,71 @@
+import { isChatCompletionChunk } from '@blocklet/ai-kit/api/types/chat';
+import retry from '../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 retry(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 (isChatCompletionChunk(chunk) && chunk.delta.content) {
+                text += chunk.delta.content;
+            }
+        }
+        const json = JSON.parse(text);
+        return json;
+    }, maxRetries);
+}
+export default generateSelectAgentName;

package/lib/esm/assistant/type.js

@@ -0,0 +1,7 @@
+export class ToolCompletionDirective extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.type = type;
+    }
+}

package/lib/esm/common/aid.js

@@ -0,0 +1,38 @@
+import { Base64 } from 'js-base64';
+export function parseIdentity(aid, options) {
+    let blockletDid;
+    let projectId;
+    let projectRef;
+    let agentId;
+    try {
+        const s = 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;
+}
+export function stringifyIdentity({ blockletDid, projectId, projectRef, agentId, }) {
+    if (typeof projectId !== 'string' || typeof agentId !== 'string') {
+        throw new Error('Invalid aid fragments');
+    }
+    return Base64.encodeURI([blockletDid || '', projectId, projectRef || '', agentId].join('/'));
+}

package/lib/esm/common/index.js

@@ -0,0 +1,232 @@
+export const defaultTextModel = 'gpt-4o-mini';
+export const supportJsonSchemaModels = ['gpt-4o', 'gpt-4o-mini'];
+export 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,
+        },
+    ];
+}
+export const defaultImageModel = 'dall-e-2';
+export 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',
+        },
+    ];
+}
+export 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/esm/common/resource-manager.js

@@ -0,0 +1,192 @@
+import { readFile, readdir } from 'fs/promises';
+import { dirname, join } from 'path';
+import { getResources } from '@blocklet/sdk/lib/component';
+import config from '@blocklet/sdk/lib/config';
+import { exists } from 'fs-extra';
+import { groupBy, throttle } from 'lodash';
+import { parse } from 'yaml';
+import { AIGNE_STUDIO_COMPONENT_DID } from '../constants';
+import logger from '../logger';
+import { ResourceTypes, validateResourceProject } from '../types';
+import { isNonNullable, isPropsNonNullable } from '../utils/is-non-nullable';
+const getResourceList = () => {
+    return ResourceTypes.flatMap((type) => getResources({ types: [{ did: AIGNE_STUDIO_COMPONENT_DID, type }], skipRunningCheck: true }).map((i) => ({
+        ...i,
+        type,
+    }))).filter(isPropsNonNullable('path'));
+};
+async function loadProjectsFromResourceBlockletDir({ did, path, }) {
+    if (!(await exists(path)))
+        return [];
+    const projectYamlPaths = (await readdir(path)).map((filename) => join(path, filename, `${filename}.yaml`));
+    return (await Promise.all(projectYamlPaths.map(async (filepath) => {
+        try {
+            const project = await validateResourceProject(parse((await readFile(filepath)).toString()));
+            return {
+                ...project,
+                blocklet: { did },
+                dir: dirname(filepath),
+                agentMap: Object.fromEntries(project.agents.map((i) => [i.id, i])),
+            };
+        }
+        catch (error) {
+            logger.error('parse aigne project resource file error', { error });
+            return null;
+        }
+    }))).filter(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 exists(item.path)))
+                return undefined;
+            const knowledgeIds = await readdir(item.path);
+            if (!knowledgeIds.length)
+                return undefined;
+            return await Promise.all(knowledgeIds.map(async (knowledgeId) => {
+                try {
+                    const knowledgePath = join(item.path, knowledgeId);
+                    const vectorsPath = join(knowledgePath, 'vectors');
+                    const uploadPath = join(knowledgePath, 'uploads');
+                    const sourcesPath = join(knowledgePath, 'sources');
+                    const processedPath = join(knowledgePath, 'processed');
+                    const logoPath = join(knowledgePath, 'logo.png');
+                    const knowledgeJsonPath = join(knowledgePath, 'knowledge.yaml');
+                    const knowledge = parse((await readFile(knowledgeJsonPath)).toString());
+                    const documentsPath = join(knowledgePath, 'documents.yaml');
+                    const documents = parse((await readFile(documentsPath)).toString());
+                    const contentsPath = join(knowledgePath, 'contents.yaml');
+                    const contents = (await exists(contentsPath)) ? parse((await readFile(contentsPath)).toString()) : [];
+                    const segmentsPath = join(knowledgePath, 'segments.yaml');
+                    const segments = (await exists(segmentsPath)) ? parse((await 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.error('read knowledge resource error', { error });
+                }
+                return undefined;
+            }));
+        }
+        catch (error) {
+            logger.error('read knowledge resource error', { error });
+        }
+        return undefined;
+    })))
+        .flat()
+        .filter(isNonNullable);
+};
+async function loadResources() {
+    const list = getResourceList().filter((i) => i.type !== 'knowledge');
+    const resources = 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(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(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])),
+                },
+            ];
+        })),
+    };
+}
+export class ResourceManager {
+    constructor({ wait = 5000, watch = true } = {}) {
+        if (watch) {
+            const reload = throttle(async () => {
+                logger.info('reload resource states');
+                await this.reload()
+                    .then((resource) => {
+                    logger.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.error('reload resource states error', { error });
+                });
+            }, wait, { leading: false, trailing: true });
+            config.events.on(config.Events.componentAdded, reload);
+            config.events.on(config.Events.componentRemoved, reload);
+            config.events.on(config.Events.componentStarted, reload);
+            config.events.on(config.Events.componentStopped, reload);
+            config.events.on(config.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() : ResourceTypes) {
+            const p = resources.agents[t]?.blockletMap[blockletDid]?.projectMap[projectId];
+            if (p)
+                return p;
+        }
+        return undefined;
+    }
+    async getAgent({ blockletDid, projectId, agentId, type = 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];
+    }
+}

package/lib/esm/constants.js

@@ -0,0 +1,6 @@
+export const AIGNE_RUNTIME_COMPONENT_DID = 'z2qaBP9SahqU2L2YA3ip7NecwKACMByTFuiJ2';
+export const AIGNE_COMPONENTS_COMPONENT_DID = 'z2qa6fvjmjew4pWJyTsKaWFuNoMUMyXDh5A1D';
+export const AIGNE_RUNTIME_CUSTOM_COMPONENT_ID = 'grc9q1cveub6pnl8';
+export const AIGNE_STUDIO_COMPONENT_DID = 'z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB';
+export const NFT_BLENDER_COMPONENT_DID = 'z8ia1ieY5KhEC4LMRETzS5nUwD7PvAND8qkfX';
+export const AIGNE_ISSUE_VC_PREFIX = 'AIGNE';

package/lib/esm/executor/agent.js

@@ -0,0 +1,6 @@
+import { AgentExecutorBase } from './base';
+export class AgentExecutor extends AgentExecutorBase {
+    async process() {
+        // ignore
+    }
+}

package/lib/esm/executor/aigc.js

@@ -0,0 +1,24 @@
+import { AgentExecutorBase } from './base';
+export class AIGCAgentExecutor extends AgentExecutorBase {
+    async process() {
+        const { agent } = this;
+        if (!agent.prompt?.length)
+            throw new Error('Prompt cannot be empty');
+        const prompt = await this.renderMessage(agent.prompt
+            .split('\n')
+            .filter((i) => !i.startsWith('//'))
+            .join('\n'));
+        const { data } = await this.context.callAIImage({
+            assistant: agent,
+            input: {
+                prompt,
+                n: agent.n,
+                model: agent.model,
+                quality: agent.quality,
+                size: agent.size,
+                style: agent.style,
+            },
+        });
+        return { $images: data };
+    }
+}

package/lib/esm/executor/api.js

@@ -0,0 +1,34 @@
+import axios, { isAxiosError } from 'axios';
+import Cookie from 'js-cookie';
+import { pick } from 'lodash';
+import { AgentExecutorBase } from './base';
+export class APIAgentExecutor extends AgentExecutorBase {
+    async process({ inputs }) {
+        const { agent } = this;
+        if (!agent.requestUrl)
+            throw new Error(`Assistant ${agent.id}'s url is empty`);
+        const args = Object.fromEntries(await Promise.all((agent.parameters ?? [])
+            .filter((i) => !!i.key && !i.hidden)
+            .map(async (i) => [i.key, inputs?.[i.key] || i.defaultValue])));
+        const method = agent.requestMethod || 'GET';
+        const isGet = method === 'get';
+        try {
+            const response = await axios({
+                url: agent.requestUrl,
+                method,
+                params: isGet ? args : undefined,
+                data: isGet ? undefined : args,
+                headers: {
+                    'x-csrf-token': Cookie.get('x-csrf-token'),
+                },
+            });
+            return response.data;
+        }
+        catch (e) {
+            if (isAxiosError(e)) {
+                Object.assign(e, pick(e.response, 'status', 'statusText', 'data'));
+            }
+            throw e;
+        }
+    }
+}