@aigne/core 0.0.2 → 0.0.4

package/lib/esm/executor/llm.js

@@ -1,372 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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/libs/blocklet/vc.js

@@ -1,85 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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 },
-    });
-};