@aigne/core 0.0.1

package/lib/esm/executor/llm.js

@@ -0,0 +1,372 @@
+import { TransformStream } from 'stream/web';
+import { isChatCompletionChunk, isChatCompletionUsage } from '@blocklet/ai-kit/api/types/index';
+import { logger } from '@blocklet/sdk/lib/config';
+import { extractMetadataFromStream, metadataOutputFormatPrompt, metadataStreamOutputFormatPrompt, } from '../assistant/generate-output';
+import { defaultTextModel, supportJsonSchemaModels } from '../common';
+import { parseIdentity, stringifyIdentity } from '../common/aid';
+import { AssistantResponseType, RuntimeOutputVariable, jsonSchemaToOpenAIJsonSchema, outputVariablesToJsonSchema, } from '../types';
+import { parseDirectives } from '../types/assistant/mustache/directive';
+import retry from '../utils/retry';
+import { nextId } from '../utils/task-id';
+import { AgentExecutorBase } from './base';
+export class LLMAgentExecutor extends AgentExecutorBase {
+    retryTimes = 0;
+    get modelInfo() {
+        const { agent } = this;
+        const model = agent.model || agent.project.model || defaultTextModel;
+        const defaultModelInfo = model === agent.project.model ? agent.project : undefined;
+        return {
+            model,
+            temperature: agent.temperature ?? defaultModelInfo?.temperature,
+            topP: agent.topP ?? defaultModelInfo?.topP,
+            presencePenalty: agent.presencePenalty ?? defaultModelInfo?.presencePenalty,
+            frequencyPenalty: agent.frequencyPenalty ?? defaultModelInfo?.frequencyPenalty,
+        };
+    }
+    _executor;
+    get executor() {
+        this._executor ??= (async () => {
+            const { agent } = this;
+            const identity = parseIdentity(agent.identity.aid, { rejectWhenError: true });
+            return agent.executor?.agent?.id
+                ? {
+                    executor: await this.context.getAgent({
+                        aid: stringifyIdentity({
+                            blockletDid: agent.executor.agent.blockletDid || identity.blockletDid,
+                            projectId: agent.executor.agent.projectId || identity.projectId,
+                            projectRef: identity.projectRef,
+                            agentId: agent.executor.agent.id,
+                        }),
+                        working: agent.identity.working,
+                        rejectOnEmpty: true,
+                    }),
+                    inputValues: agent.executor.inputValues,
+                }
+                : agent.project.executor?.agent?.id
+                    ? {
+                        executor: await this.context.getAgent({
+                            aid: stringifyIdentity({
+                                blockletDid: agent.project.executor.agent.blockletDid || identity.blockletDid,
+                                projectId: agent.project.executor.agent.projectId || identity.projectId,
+                                projectRef: identity.projectRef,
+                                agentId: agent.project.executor.agent.id,
+                            }),
+                            working: agent.identity.working,
+                            rejectOnEmpty: true,
+                        }),
+                        inputValues: agent.project.executor.inputValues,
+                    }
+                    : undefined;
+        })();
+        return this._executor;
+    }
+    _outputsInfo;
+    get outputsInfo() {
+        this._outputsInfo ??= (async () => {
+            const { agent } = this;
+            const outputVariables = (agent.outputVariables ?? []).filter((i) => !!i.name && !i.hidden && i.from?.type !== 'callAgent') ?? [];
+            const schema = outputVariablesToJsonSchema(agent, {
+                variables: await this.context.getMemoryVariables({
+                    ...parseIdentity(agent.identity.aid, { rejectWhenError: true }),
+                    working: agent.identity.working,
+                }),
+            });
+            const hasStreamingTextOutput = outputVariables.some((i) => i.name === RuntimeOutputVariable.text);
+            const hasJsonOutputs = !!schema && Object.values(schema.properties).length > 0;
+            return { outputs: outputVariables, schema, hasStreamingTextOutput, hasJsonOutputs };
+        })();
+        return this._outputsInfo;
+    }
+    getMessages({ inputs }) {
+        const { agent } = this;
+        const createContentStructure = async (content, variables, agent, prompt) => {
+            const parameters = agent.parameters ?? [];
+            // 没有特殊变量
+            if (!variables.length) {
+                const renderedContent = await this.renderMessage(content, { ...inputs, ...this.globalContext });
+                return renderedContent;
+            }
+            // 没有图片变量
+            const haveImageParameter = parameters.filter((i) => i.type === 'image').some((i) => variables.includes(i.key));
+            if (!haveImageParameter) {
+                const renderedContent = await this.renderMessage(content, { ...inputs, ...this.globalContext });
+                return renderedContent;
+            }
+            // 创建图片变量标记
+            const createImageMarker = (variable) => `__IMAGE_${variable}__`;
+            const imageVariablesMap = {};
+            const imageVariables = [];
+            // 当前参数有图片变量
+            parameters
+                .filter((i) => i.type === 'image' && i.key && variables.includes(i.key))
+                .forEach((param) => {
+                if (param.type === 'image' && param.key && inputs[param.key]) {
+                    const marker = createImageMarker(param.key);
+                    imageVariablesMap[param.key] = marker;
+                    imageVariables.push({ marker, value: inputs[param.key] });
+                }
+            });
+            const renderedContent = await this.renderMessage(content, {
+                ...inputs,
+                ...this.globalContext,
+                ...imageVariablesMap,
+            });
+            const contentParts = [];
+            if (imageVariables.length === 0) {
+                return renderedContent;
+            }
+            let remainingContent = renderedContent;
+            for (const { marker, value } of imageVariables) {
+                const parts = remainingContent.split(marker);
+                if (parts[0]) {
+                    contentParts.push({ type: 'text', text: parts[0] });
+                }
+                // 只有是 user 时，才处理
+                if (prompt.data.role === 'user') {
+                    const list = Array.isArray(value) ? value : [value];
+                    list.forEach((item) => contentParts.push({ type: 'image_url', imageUrl: { url: item } }));
+                }
+                remainingContent = parts[1] || '';
+            }
+            if (remainingContent) {
+                contentParts.push({ type: 'text', text: remainingContent });
+            }
+            logger.info('have image messages', contentParts);
+            return contentParts;
+        };
+        return (async () => (await Promise.all((agent.prompts ?? [])
+            .filter((i) => i.visibility !== 'hidden')
+            .map(async (prompt) => {
+            if (prompt.type === 'message') {
+                const content = prompt.data.content
+                    ?.split('\n')
+                    .filter((i) => !i.startsWith('//'))
+                    .join('\n') || '';
+                const variables = parseDirectives(content)
+                    .filter((i) => i.type === 'variable')
+                    .map((i) => i.name);
+                const contentStructure = await createContentStructure(content, variables, agent, prompt);
+                return {
+                    role: prompt.data.role,
+                    content: contentStructure,
+                };
+            }
+            console.warn('Unsupported prompt type', prompt);
+            return undefined;
+        })))
+            .flat()
+            .filter((i) => !!i?.content))();
+    }
+    async process({ inputs }) {
+        const { hasJsonOutputs } = await this.outputsInfo;
+        const messages = await this.getMessages({ inputs });
+        const { modelInfo } = this;
+        const e = await this.executor;
+        // NOTE: use json_schema output for models that support it
+        if (supportJsonSchemaModels.includes(modelInfo.model) &&
+            hasJsonOutputs &&
+            // check the llm executor is support json schema output
+            (!e || e.executor.parameters?.some((i) => i.type === 'llmInputResponseFormat'))) {
+            return this.processWithJsonSchemaFormat({ messages, inputs });
+        }
+        return this.processWithOutJsonSchemaFormatSupport({ inputs, messages });
+    }
+    async processWithOutJsonSchemaFormatSupport({ inputs, messages, }) {
+        const { agent, options: { taskId, parentTaskId }, } = this;
+        const { hasStreamingTextOutput, hasJsonOutputs, schema } = await this.outputsInfo;
+        const outputSchema = JSON.stringify(schema);
+        const messagesWithSystemPrompt = [...messages];
+        const lastSystemIndex = messagesWithSystemPrompt.findLastIndex((i) => i.role === 'system');
+        if (hasJsonOutputs) {
+            if (hasStreamingTextOutput) {
+                messagesWithSystemPrompt.splice(lastSystemIndex + 1, 0, {
+                    role: 'system',
+                    content: metadataStreamOutputFormatPrompt(outputSchema),
+                });
+            }
+            else {
+                messagesWithSystemPrompt.splice(lastSystemIndex + 1, 0, {
+                    role: 'system',
+                    content: metadataOutputFormatPrompt(outputSchema),
+                });
+            }
+        }
+        if (!messagesWithSystemPrompt.length)
+            return undefined;
+        this.context.callback?.({
+            type: AssistantResponseType.INPUT,
+            assistantId: agent.id,
+            parentTaskId,
+            taskId,
+            assistantName: agent.name,
+            inputParameters: this.hideSecretInputs(inputs, agent),
+            promptMessages: messagesWithSystemPrompt,
+        });
+        const run = async () => {
+            this.retryTimes += 1;
+            let result = '';
+            const metadataStrings = [];
+            const chatCompletionChunk = await this.callAIOrExecutor({ messages: messagesWithSystemPrompt, inputs });
+            const stream = extractMetadataFromStream(chatCompletionChunk.pipeThrough(new TransformStream({
+                transform: (chunk, controller) => {
+                    if (isChatCompletionUsage(chunk)) {
+                        this.context.callback?.({
+                            type: AssistantResponseType.USAGE,
+                            taskId,
+                            assistantId: agent.id,
+                            usage: chunk.usage,
+                        });
+                    }
+                    controller.enqueue(chunk);
+                },
+            })), hasJsonOutputs);
+            for await (const chunk of stream) {
+                if (chunk.type === 'text') {
+                    const { text } = chunk;
+                    result += text;
+                    if (hasStreamingTextOutput && this.retryTimes === 1) {
+                        this.context.callback?.({
+                            type: AssistantResponseType.CHUNK,
+                            taskId,
+                            assistantId: agent.id,
+                            delta: { content: text },
+                        });
+                    }
+                }
+                else if (chunk.type === 'match') {
+                    metadataStrings.push(chunk.text);
+                }
+            }
+            const json = {};
+            for (const i of metadataStrings) {
+                try {
+                    const obj = JSON.parse(i);
+                    Object.assign(json, obj);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            // try to parse all text content as a json
+            try {
+                Object.assign(json, JSON.parse(result));
+            }
+            catch {
+                // ignore
+            }
+            try {
+                return await super.validateOutputs({
+                    inputs,
+                    outputs: { ...json, $text: result },
+                });
+            }
+            catch (error) {
+                logger.error('validate LLM outputs error', error);
+                throw new Error('Unexpected response format from AI');
+            }
+        };
+        return await retry(run, this.context.maxRetries);
+    }
+    async processWithJsonSchemaFormat({ messages, inputs, }) {
+        const { agent, options: { parentTaskId, taskId }, } = this;
+        this.context.callback?.({
+            type: AssistantResponseType.INPUT,
+            assistantId: agent.id,
+            parentTaskId,
+            taskId,
+            assistantName: agent.name,
+            inputParameters: this.hideSecretInputs(inputs, agent),
+            promptMessages: messages,
+        });
+        const { hasStreamingTextOutput, schema } = await this.outputsInfo;
+        const [json, { text }] = await Promise.all([
+            this.callAIGetJsonOutput({ messages, schema }),
+            hasStreamingTextOutput ? this.callAIGetTextStreamOutput({ messages, inputs }) : { text: undefined },
+        ]);
+        try {
+            return await super.validateOutputs({
+                inputs,
+                outputs: { ...json, $text: text },
+            });
+        }
+        catch (error) {
+            logger.error('validate LLM outputs error', error);
+            throw new Error('Unexpected response format from AI');
+        }
+    }
+    async callAIGetJsonOutput({ messages, schema }) {
+        const { modelInfo } = this;
+        const result = await this.context.callAI({
+            assistant: this.agent,
+            input: {
+                messages,
+                ...modelInfo,
+                responseFormat: {
+                    type: 'json_schema',
+                    jsonSchema: {
+                        name: 'output',
+                        schema: jsonSchemaToOpenAIJsonSchema(schema),
+                        strict: true,
+                    },
+                },
+            },
+        });
+        let json = '';
+        for await (const i of result) {
+            if (isChatCompletionChunk(i)) {
+                json += i.delta.content || '';
+            }
+        }
+        try {
+            return JSON.parse(json);
+        }
+        catch (error) {
+            logger.error(json, error);
+            throw new Error('parse ai json schema output error');
+        }
+    }
+    async callAIGetTextStreamOutput({ messages, inputs, }) {
+        const { agent, options: { taskId }, } = this;
+        const stream = await this.callAIOrExecutor({
+            messages,
+            inputs,
+        });
+        let text = '';
+        for await (const chunk of stream) {
+            if (isChatCompletionChunk(chunk)) {
+                text += chunk.delta.content || '';
+                this.context.callback?.({
+                    type: AssistantResponseType.CHUNK,
+                    taskId,
+                    assistantId: agent.id,
+                    delta: { content: chunk.delta.content },
+                });
+            }
+        }
+        return { text };
+    }
+    async callAIOrExecutor({ messages, inputs, }) {
+        const { agent, modelInfo, options: { taskId }, } = this;
+        const e = await this.executor;
+        return e
+            ? (await this.context
+                .executor(e.executor, {
+                inputs: {
+                    ...inputs,
+                    ...e.inputValues,
+                    [e.executor.parameters?.find((i) => i.type === 'llmInputMessages' && !i.hidden)?.key]: messages,
+                },
+                taskId: nextId(),
+                parentTaskId: taskId,
+            })
+                .execute())[RuntimeOutputVariable.llmResponseStream]
+            : await this.context.callAI({
+                assistant: agent,
+                input: {
+                    stream: true,
+                    messages,
+                    ...modelInfo,
+                },
+            });
+    }
+}

package/lib/esm/executor/logic.js

@@ -0,0 +1,160 @@
+import crypto from 'crypto';
+import { Sandbox } from '@blocklet/quickjs';
+import { call, getComponentMountPoint } from '@blocklet/sdk/lib/component';
+import config from '@blocklet/sdk/lib/config';
+import equal from 'fast-deep-equal';
+import Joi from 'joi';
+import pick from 'lodash/pick';
+import { parseIdentity, stringifyIdentity } from '../common/aid';
+import logger from '../logger';
+import { AssistantResponseType } from '../types';
+import { renderMustacheStream } from '../types/assistant/mustache/ReadableMustache';
+import { geti } from '../utils/geti';
+import { nextId } from '../utils/task-id';
+import { AgentExecutorBase } from './base';
+async function parseJSONInVM(str) {
+    return Sandbox.callFunction({
+        code: `\
+function parse(json) {
+  return eval(\`const j = \${json}; j\`)
+}
+`,
+        filename: 'parserJSONInVm.js',
+        functionName: 'parse',
+        args: [str.trim()],
+    });
+}
+export class LogicAgentExecutor extends AgentExecutorBase {
+    async process({ inputs }) {
+        const { agent, options: { taskId }, } = this;
+        if (!agent.code)
+            throw new Error(`Assistant ${agent.id}'s code 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 $json = (variables, ...rest) => {
+            const taggedFn = async (t, ...rest) => {
+                const template = t.map((s, i) => `${s}${i === t.length - 1 ? '' : rest[i]}`).join('');
+                const renderCtx = {
+                    ...args,
+                    ...variables,
+                    ...this.globalContext,
+                    get: () => async (template, render) => {
+                        const s = await render(template);
+                        return geti(renderCtx, s);
+                    },
+                    runAgent: () => async (template, render) => {
+                        const t = (await parseJSONInVM(template))?.template;
+                        const s = await render(template);
+                        const j = await parseJSONInVM(s);
+                        const { agentId, inputs } = await Joi.object({
+                            agentId: Joi.string().required(),
+                            inputs: Joi.object().pattern(Joi.string(), Joi.any()).required(),
+                        }).validateAsync(j, { stripUnknown: true });
+                        const a = await this.context.getAgent({
+                            aid: stringifyIdentity({ ...parseIdentity(agent.identity.aid, { rejectWhenError: true }), agentId }),
+                            working: agent.identity.working,
+                            rejectOnEmpty: true,
+                        });
+                        const result = await this.context.execute(a, { taskId: nextId(), parentTaskId: taskId, inputs });
+                        return this.renderMessage(t, { ...renderCtx, $result: result }, { escapeJsonSymbols: true });
+                    },
+                };
+                const result = renderMustacheStream(template, (enqueue) => ({
+                    ...renderCtx,
+                    runAgent: () => enqueue(renderCtx.runAgent()),
+                }));
+                let object;
+                for await (const chunk of result) {
+                    const newObj = await parseJSONInVM(chunk);
+                    // skip if the object is equal
+                    // TODO: throttle the output
+                    if (equal(object, newObj)) {
+                        continue;
+                    }
+                    object = newObj;
+                    try {
+                        const obj = await this.validateOutputs({ outputs: object, partial: true });
+                        this.context.callback?.({
+                            type: AssistantResponseType.CHUNK,
+                            taskId,
+                            assistantId: agent.id,
+                            delta: { object: obj },
+                        });
+                    }
+                    catch (error) {
+                        logger.error('validate LLM outputs error', error, object);
+                    }
+                }
+                return object;
+            };
+            // 支持 $json({foo:"xxx"})`` 和 $json`` 两种调用方式
+            if (Array.isArray(variables)) {
+                return taggedFn(variables, ...rest);
+            }
+            return taggedFn;
+        };
+        const log = (...args) => this.context.callback({
+            type: AssistantResponseType.LOG,
+            log: JSON.stringify(args),
+            timestamp: Date.now(),
+            taskId,
+            assistantId: agent.id,
+        });
+        const global = {
+            console: {
+                // NOTE: do not return logger.xxx result, it will cause memory leak
+                log: (...args) => log(...args),
+                info: (...args) => log(...args),
+                debug: (...args) => log(...args),
+                warn: (...args) => log(...args),
+                error: (...args) => log(...args),
+            },
+            getComponentMountPoint,
+            call: (...args) => call(...args).then((res) => ({ data: res.data })),
+            crypto: { randomInt: crypto.randomInt },
+            config: { env: pick(config.env, 'appId', 'appName', 'appDescription', 'appUrl') },
+        };
+        const allArgs = {
+            $json,
+            runAgent: async ({ agentId, inputs, streaming, }) => {
+                const a = await this.context.getAgent({
+                    aid: stringifyIdentity({ ...parseIdentity(agent.identity.aid, { rejectWhenError: true }), agentId }),
+                    working: agent.identity.working,
+                    rejectOnEmpty: true,
+                });
+                const { callback } = this.context;
+                const currentTaskId = nextId();
+                return this.context
+                    .copy(streaming
+                    ? {
+                        callback: function hello(args) {
+                            callback(args);
+                            if (args.type === AssistantResponseType.CHUNK &&
+                                args.delta.content &&
+                                args.taskId === currentTaskId) {
+                                callback({ ...args, taskId });
+                            }
+                        },
+                    }
+                    : {})
+                    .execute(a, { taskId: currentTaskId, parentTaskId: taskId, inputs });
+            },
+            ...this.globalContext,
+            ...args,
+        };
+        const argKeys = Object.keys(allArgs);
+        const resultPromise = await Sandbox.callFunction({
+            code: `\
+async function main({${argKeys.join(', ')}) {
+  ${agent.code}
+}
+`,
+            filename: `${agent.name || agent.id}.js`,
+            global,
+            functionName: 'main',
+            args: [allArgs],
+        });
+        return resultPromise;
+    }
+}

package/lib/esm/index.js

@@ -0,0 +1 @@
+export * from './runtime/runtime';

package/lib/esm/libs/blocklet/vc.js

@@ -0,0 +1,85 @@
+import AuthService from '@blocklet/sdk/lib/service/auth';
+import { AIGNE_ISSUE_VC_PREFIX } from '../../constants';
+export const authService = new AuthService();
+export async function issueVC({ context: { entry }, userDid, name, title, description, reissue = false, displayUrl, notify = true, }) {
+    // NOTE: ensure name starts with AIGNE_ISSUE_VC_PREFIX to avoid conflict with internal passports such as admin/owner
+    if (!name.startsWith(AIGNE_ISSUE_VC_PREFIX))
+        name = `${AIGNE_ISSUE_VC_PREFIX}${name}`;
+    await createPassportIfNotExist({ name, title, description });
+    const userResult = await authService.getUser(userDid, { includeTags: true });
+    if (!userResult.user)
+        throw new Error(`User not found ${userDid}`);
+    if (!reissue) {
+        const vc = userResult.user.passports.find((p) => p.role === name);
+        if (vc)
+            return { user: userResult.user, vc };
+    }
+    const issueResult = await authService.issuePassportToUser({
+        userDid,
+        role: name,
+        display: displayUrl ? { type: 'url', content: displayUrl } : undefined,
+        notify,
+        notification: JSON.stringify({
+            title: `You just received a VC ${title}`,
+            body: description,
+            attachments: [
+                {
+                    type: 'image',
+                    data: {
+                        url: displayUrl,
+                        alt: title,
+                    },
+                },
+            ],
+            appInfo: {
+                title: entry.project.name,
+                // logo: getProjectIconUrl(entry.project.id, {
+                //   blockletDid: entry.blockletDid,
+                //   working: entry.working,
+                //   updatedAt: entry.project.updatedAt,
+                // }),
+                url: entry.appUrl,
+                description: entry.project.description,
+            },
+            poweredBy: {
+                name: 'AIGNE',
+                url: 'https://www.aigne.io',
+            },
+            severity: 'success',
+        }),
+    });
+    if (issueResult.code !== 'ok')
+        throw new Error(`Issue VC failed got ${issueResult.code}`);
+    const vc = issueResult.user.passports.findLast((p) => p.role === name);
+    if (!vc)
+        throw new Error('Issue VC got empty result');
+    return { user: issueResult.user, vc };
+}
+const CREATE_PASSPORT_TASKS = {};
+async function createPassportIfNotExist({ name, title, description, }) {
+    CREATE_PASSPORT_TASKS[name] ??= (async () => {
+        try {
+            let result = await authService.getRole(name);
+            if (!result.role) {
+                // Create a role for custom display
+                result = await authService.createRole({
+                    title,
+                    name,
+                    description,
+                    permissions: [],
+                    extra: JSON.stringify({
+                        display: 'custom',
+                        types: [name],
+                    }),
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            // NOTE: reset task if failed
+            delete CREATE_PASSPORT_TASKS[name];
+            throw error;
+        }
+    })();
+    return CREATE_PASSPORT_TASKS[name];
+}

package/lib/esm/libs/openapi/request/index.js

@@ -0,0 +1,20 @@
+import { call } from '@blocklet/sdk/lib/component';
+import { getRequestConfig } from './util';
+export const callBlockletApi = (pathItem, data, options) => {
+    const requestConfig = getRequestConfig(pathItem, data, {
+        params: options?.params || {},
+        data: options?.data || {},
+    });
+    const { headers, method, url, params, ...config } = requestConfig;
+    const did = options?.user?.did || '';
+    if (!pathItem.name)
+        throw new Error('Blocklet name is required to call blocklet api');
+    return call({
+        ...config,
+        method: method,
+        name: pathItem.name,
+        path: url,
+        headers,
+        params: { ...params, userId: did },
+    });
+};