@aigne/core 0.0.3 → 0.0.4

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

@@ -1,136 +0,0 @@
-import convertSchemaToObject from '../util/convert-schema';
-export const getRequestConfig = (pathItem, requestData, options) => {
-    let url = pathItem.path || '';
-    const config = {
-        method: pathItem.method,
-        url,
-        headers: {},
-        params: options?.params || {},
-        data: options?.data || {},
-        cookies: {},
-        body: {},
-    };
-    const data = { ...requestData };
-    const requestBodyData = { ...data };
-    for (const parameter of pathItem.parameters || []) {
-        if (Object.prototype.hasOwnProperty.call(data, parameter.name)) {
-            const value = data[parameter.name];
-            switch (parameter.in) {
-                case 'path':
-                    url = url.replace(`{${parameter.name}}`, encodeURIComponent(value));
-                    break;
-                case 'query':
-                    config.params[parameter.name] = value;
-                    break;
-                case 'header':
-                    config.headers[parameter.name] = value;
-                    break;
-                case 'cookie':
-                    config.cookies[parameter.name] = value;
-                    break;
-                default:
-                    throw new Error('Unsupported parameter type');
-            }
-            delete requestBodyData[parameter.name];
-        }
-    }
-    if (['POST', 'PUT', 'PATCH'].includes(pathItem.method.toUpperCase()) && pathItem.requestBody) {
-        config.headers['Content-Type'] = getContentType(pathItem.requestBody);
-        config.data = getRequestBody(pathItem.requestBody, requestBodyData || {});
-    }
-    config.url = url;
-    config.body = requestBodyData;
-    return config;
-};
-function getContentType(requestBody) {
-    if (requestBody && requestBody.content) {
-        const [firstMediaType] = Object.keys(requestBody.content);
-        return firstMediaType || 'application/json';
-    }
-    return 'application/json';
-}
-function getRequestBody(requestBody, requestBodyData) {
-    if (requestBody && requestBody.content) {
-        const contentType = getContentType(requestBody);
-        const mediaTypeObject = requestBody.content[contentType];
-        if (mediaTypeObject && mediaTypeObject.schema) {
-            switch (contentType) {
-                case 'application/json':
-                    return JSON.stringify(requestBodyData);
-                case 'application/x-www-form-urlencoded':
-                    return serializeFormEncoded(requestBodyData);
-                case 'multipart/form-data':
-                    // eslint-disable-next-line no-case-declarations
-                    const formData = new FormData();
-                    Object.keys(requestBodyData).forEach((key) => {
-                        const value = requestBodyData[key];
-                        if (Array.isArray(value)) {
-                            value.forEach((item, index) => formData.append(`${key}[${index}]`, item));
-                        }
-                        else if (typeof value === 'object' && value !== null) {
-                            Object.keys(value).forEach((subKey) => {
-                                formData.append(`${key}[${subKey}]`, value[subKey]);
-                            });
-                        }
-                        else {
-                            formData.append(key, value);
-                        }
-                    });
-                    return formData;
-                default:
-                    throw new Error(`Unsupported content type: ${contentType}`);
-            }
-        }
-    }
-    return requestBodyData;
-}
-function serializeFormEncoded(data) {
-    return Object.keys(data)
-        .map((key) => {
-        const value = data[key];
-        if (typeof value === 'object' && value !== null) {
-            return serializeNestedObject(key, value);
-        }
-        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-    })
-        .join('&');
-}
-function serializeNestedObject(parentKey, obj) {
-    return Object.keys(obj)
-        .map((key) => {
-        const value = obj[key];
-        const fullKey = `${parentKey}[${key}]`;
-        if (typeof value === 'object' && value !== null) {
-            return serializeNestedObject(fullKey, value);
-        }
-        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value)}`;
-    })
-        .join('&');
-}
-export function extractRequestBodyParameters(requestBody) {
-    if (!requestBody || !requestBody.content) {
-        return [];
-    }
-    const contentType = getContentType(requestBody);
-    const mediaTypeObject = requestBody.content[contentType];
-    if (!mediaTypeObject || !mediaTypeObject.schema) {
-        console.warn(`No schema available for content type: ${contentType}`);
-        return [];
-    }
-    const { schema } = mediaTypeObject;
-    const schemaObject = convertSchemaToObject(schema);
-    return Object.entries(schemaObject).map(([key, value]) => ({ name: key, ...value })) || [];
-}
-export function getAllParameters(dataset) {
-    const requestBody = extractRequestBodyParameters(dataset?.requestBody);
-    const datasetParameters = [
-        ...(dataset?.parameters ?? []).map((i) => ({ ...i, type: i.schema?.type })),
-        ...(requestBody ?? []),
-    ];
-    return datasetParameters;
-}
-export function getRequiredFields(dataset) {
-    const parameterFields = dataset.parameters?.filter((param) => param.required).map((param) => param.name) || [];
-    const requestBodyFields = Object.values(dataset.requestBody?.content || {}).flatMap((mediaObject) => mediaObject.schema?.required || []);
-    return [...new Set([...parameterFields, ...requestBodyFields])];
-}

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

@@ -1 +0,0 @@
-export * from 'openapi3-ts/oas31';

package/lib/esm/libs/openapi/util/call.js

@@ -1,8 +0,0 @@
-import { call as originalCall } from '@blocklet/sdk/lib/component';
-import isNil from 'lodash/isNil';
-export const call = (options) => {
-    return originalCall({
-        ...options,
-        params: Object.fromEntries(Object.entries(options.params ?? {}).map(([key, value]) => [key, isNil(value) ? '' : String(value)])),
-    });
-};

package/lib/esm/libs/openapi/util/check-schema.js

@@ -1,62 +0,0 @@
-import Joi from 'joi';
-const CustomJoi = Joi.extend((joi) => ({
-    type: 'string',
-    base: joi.string(),
-    messages: {
-        'string.customId': '{{#label}} does not match the expected format (type:path:method)',
-    },
-    rules: {
-        customId: {
-            validate(value, helpers) {
-                const [, path, method] = value.split(':');
-                const parts = helpers.state.ancestors[0];
-                if (!path || !method) {
-                    return helpers.error('string.customId');
-                }
-                if (path !== parts.path || (method || '').toLocaleLowerCase() !== (parts.method || '').toLocaleLowerCase()) {
-                    return helpers.error('string.customId');
-                }
-                return value;
-            },
-        },
-    },
-}));
-const BaseParameterObjectSchema = Joi.object({
-    description: Joi.string().optional(),
-    required: Joi.boolean().optional(),
-    deprecated: Joi.boolean().optional(),
-    allowEmptyValue: Joi.boolean().optional(),
-    style: Joi.string()
-        .valid('matrix', 'label', 'form', 'simple', 'spaceDelimited', 'pipeDelimited', 'deepObject')
-        .insensitive()
-        .optional(),
-    explode: Joi.boolean().optional(),
-    allowReserved: Joi.boolean().optional(),
-    schema: Joi.any().optional(),
-    examples: Joi.object().pattern(Joi.string(), Joi.any).optional(),
-    example: Joi.any().optional(),
-    content: Joi.any().optional(),
-}).optional();
-const ParameterObjectSchema = BaseParameterObjectSchema.keys({
-    name: Joi.string().required(),
-    in: Joi.string().valid('query', 'header', 'path', 'cookie').insensitive().required(),
-});
-const RequestBodyObjectSchema = Joi.object({});
-const ResponsesObjectSchema = Joi.object({});
-export default Joi.object({
-    id: CustomJoi.string().customId().required(),
-    name: Joi.string().optional().allow('').empty([null, '']),
-    type: Joi.string().optional().allow('').empty([null, '']),
-    url: Joi.string()
-        .pattern(/^https?:\/\//)
-        .optional()
-        .allow('')
-        .empty([null, '']),
-    path: Joi.string().required(),
-    method: Joi.string().valid('GET', 'POST', 'PUT', 'DELETE', 'PATCH').insensitive().required(),
-    summary: Joi.string().optional().allow('').empty([null, '']),
-    description: Joi.string().optional().allow('').empty([null, '']),
-    parameters: Joi.array().items(ParameterObjectSchema).optional().allow(null, '').empty([null, '']),
-    requestBody: RequestBodyObjectSchema.optional().allow('').empty([null, '']),
-    responses: ResponsesObjectSchema.optional().allow('').empty([null, '']),
-}).unknown(true);

package/lib/esm/libs/openapi/util/convert-schema.js

@@ -1,42 +0,0 @@
-const convertSchemaToObject = (schema) => {
-    if (!schema || typeof schema !== 'object') {
-        throw new Error('Invalid schema: Schema must be an object');
-    }
-    switch (schema.type) {
-        case 'object':
-            return convertObjectSchema(schema);
-        case 'array':
-            return convertArraySchema(schema);
-        default:
-            return convertPrimitiveSchema(schema);
-    }
-};
-const convertObjectSchema = (schema) => {
-    const result = {};
-    if (schema.properties && typeof schema.properties === 'object') {
-        Object.keys(schema.properties).forEach((property) => {
-            result[property] = schema.properties[property];
-        });
-    }
-    return result;
-};
-const convertArraySchema = (schema) => {
-    if (!schema.items) {
-        return [];
-    }
-    return [convertSchemaToObject(schema.items)];
-};
-const convertPrimitiveSchema = (schema) => {
-    switch (schema.type) {
-        case 'string':
-            return { ...schema, value: schema.default ?? (schema.enum ? schema.enum[0] : '') };
-        case 'integer':
-        case 'number':
-            return { ...schema, value: schema.default ?? 0 };
-        case 'boolean':
-            return { ...schema, value: schema.default ?? false };
-        default:
-            return { ...schema, value: schema.default ?? null };
-    }
-};
-export default convertSchemaToObject;

package/lib/esm/libs/openapi/util/flatten-open-api.js

@@ -1,19 +0,0 @@
-function flattenApiStructure(apiStructure) {
-    const flattened = [];
-    const paths = apiStructure?.paths || {};
-    for (const path in paths) {
-        for (const method in paths[path]) {
-            const endpoint = paths[path]?.[method];
-            flattened.push({
-                id: endpoint['x-id'],
-                name: endpoint['x-did'],
-                path: endpoint['x-path'],
-                method: endpoint['x-method'],
-                did: endpoint['x-did'],
-                ...endpoint,
-            });
-        }
-    }
-    return flattened;
-}
-export default flattenApiStructure;

package/lib/esm/libs/openapi/util/get-open-api-i18n-text.js

@@ -1,5 +0,0 @@
-const getOpenApiTextFromI18n = (data, key, locale) => {
-    const i18nKey = `x-${key}-${locale}`;
-    return data[i18nKey] || data[key];
-};
-export default getOpenApiTextFromI18n;

package/lib/esm/runtime/resource-blocklet.js

@@ -1,2 +0,0 @@
-import { ResourceManager } from '../common/resource-manager';
-export const resourceManager = new ResourceManager();

package/lib/esm/runtime/runtime.js

@@ -1,136 +0,0 @@
-import { join } from 'path';
-import { chatCompletions, imageGenerations } from '@blocklet/ai-kit/api/call';
-import { readFile } from 'fs-extra';
-import { glob } from 'glob';
-import { parse } from 'yaml';
-import { defaultImageModel, defaultTextModel, getSupportedImagesModels } from '../common';
-import { parseIdentity, stringifyIdentity } from '../common/aid';
-import { RuntimeExecutor } from '../executor';
-import logger from '../logger';
-import { nextId } from '../utils/task-id';
-import { resourceManager } from './resource-blocklet';
-export class AIGNERuntime {
-    project;
-    static async load(options) {
-        const projectFilePath = join(options.path, 'project.yaml');
-        const project = parse((await readFile(projectFilePath)).toString());
-        // TODO: validate parsed project
-        const agentFilePaths = await glob(join(options.path, 'prompts', '**/*.yaml'));
-        const agents = await Promise.all(agentFilePaths.map(async (filename) => {
-            const agent = parse((await readFile(filename)).toString());
-            // TODO: validate parsed agent
-            return agent;
-        }));
-        const memoryFilePath = join(options.path, 'config/variable.yaml');
-        const memories = parse((await readFile(memoryFilePath)).toString())?.variables;
-        // TODO: validate parsed memories
-        const p = {
-            ...project,
-            agents,
-            memories,
-        };
-        return new AIGNERuntime(p);
-    }
-    constructor(project) {
-        this.project = project;
-    }
-    async runAgent(agentId, inputs) {
-        const agent = this.project.agents?.find((a) => a.id === agentId);
-        if (!agent)
-            throw new Error(`Agent ${agentId} not found`);
-        const taskId = nextId();
-        const messageId = nextId();
-        const callAI = async ({ input }) => {
-            return await chatCompletions({ ...input, model: input.model || defaultTextModel });
-        };
-        const callAIImage = async ({ assistant, input }) => {
-            const imageAssistant = assistant.type === 'image' ? assistant : undefined;
-            const supportImages = await getSupportedImagesModels();
-            const imageModel = supportImages.find((i) => i.model === (imageAssistant?.model || defaultImageModel));
-            const model = {
-                model: input.model || imageModel?.model,
-                n: input.n || imageModel?.nDefault,
-                quality: input.quality || imageModel?.qualityDefault,
-                style: input.style || imageModel?.styleDefault,
-                size: input.size || imageModel?.sizeDefault,
-            };
-            return imageGenerations({
-                ...input,
-                ...model,
-                responseFormat: 'url',
-            });
-        };
-        const executor = new RuntimeExecutor({
-            entry: { project: this.project },
-            callback: () => { },
-            callAI,
-            callAIImage,
-            getMemoryVariables: async (options) => {
-                if (options.projectId === this.project.id)
-                    return this.project.memories ?? [];
-                logger.warn('Unsupported to get memory variables from other projects');
-                return [];
-            },
-            getAgent: async (options) => {
-                const identity = parseIdentity(options.aid, { rejectWhenError: true });
-                let agent;
-                if (identity.blockletDid) {
-                    const { blockletDid, projectId, agentId } = identity;
-                    const res = await resourceManager.getAgent({ blockletDid, projectId, agentId });
-                    if (res) {
-                        agent = {
-                            ...res.agent,
-                            project: res.project,
-                            identity: {
-                                blockletDid,
-                                projectId,
-                                agentId,
-                                aid: stringifyIdentity({ blockletDid, projectId, agentId }),
-                            },
-                        };
-                    }
-                }
-                else if (identity.projectId === this.project.id) {
-                    const a = this.project.agents?.find((a) => a.id === identity.agentId);
-                    if (a) {
-                        agent = {
-                            ...a,
-                            project: this.project,
-                            identity: {
-                                projectId: this.project.id,
-                                agentId: a.id,
-                                aid: stringifyIdentity({ projectId: this.project.id, agentId: a.id }),
-                            },
-                        };
-                    }
-                }
-                if (options.rejectOnEmpty && !agent)
-                    throw new Error('No such agent');
-                return agent;
-            },
-            entryProjectId: this.project.id,
-            sessionId: this.project.id,
-            messageId,
-            clientTime: new Date().toISOString(),
-            queryCache: async ({ aid, cacheKey }) => {
-                // TODO: implement cache
-                return null;
-            },
-            setCache: async ({ aid, cacheKey, inputs, outputs }) => {
-                // TODO: implement cache
-            },
-        }, {
-            ...agent,
-            identity: {
-                projectId: this.project.id,
-                agentId: agent.id,
-                aid: stringifyIdentity({ projectId: this.project.id, agentId: agent.id }),
-            },
-            project: this.project,
-        }, {
-            inputs,
-            taskId,
-        });
-        return executor.execute();
-    }
-}

package/lib/esm/types/assistant/index.js

@@ -1,9 +0,0 @@
-export { default as Mustache } from './mustache/mustache';
-export * from './mustache/directive';
-export var OnTaskCompletion;
-(function (OnTaskCompletion) {
-    OnTaskCompletion["EXIT"] = "EXIT";
-})(OnTaskCompletion || (OnTaskCompletion = {}));
-export function isUserInputParameter(parameter) {
-    return parameter.type !== 'source';
-}

package/lib/esm/types/assistant/mustache/ReadableMustache.js

@@ -1,63 +0,0 @@
-import { ReadableStream } from 'stream/web';
-import fastq from 'fastq';
-import { renderMessage } from '../../../utils/render-message';
-export function renderMustacheStream(template, context) {
-    return new ReadableStream({
-        async start(controller) {
-            try {
-                // 异步任务队列，每个任务完成之后都会重新渲染模板并返回最新的结果到流中
-                const queue = fastq.promise(async (p) => {
-                    await p;
-                    await render();
-                }, 100);
-                let reject;
-                const errorPromise = new Promise((_, rej) => {
-                    reject = rej;
-                });
-                queue.error((error) => {
-                    if (error)
-                        reject?.(error);
-                });
-                // 任务缓存，每个任务的 key 为渲染后的子模板（其中可能包含参数）
-                const cache = new Map();
-                const ctx = context((fn) => {
-                    return async (template, render) => {
-                        const rendered = await render(template);
-                        const key = rendered;
-                        let task = cache.get(key);
-                        if (!task) {
-                            const res = fn(template, render, rendered);
-                            if (res instanceof Promise) {
-                                task = { promise: res };
-                                res
-                                    .then((value) => {
-                                    task.result = { data: value };
-                                })
-                                    .catch((error) => {
-                                    task.error = { error };
-                                });
-                                queue.push(res);
-                            }
-                            else {
-                                task = { result: { data: res } };
-                            }
-                            cache.set(key, task);
-                        }
-                        if (task.error)
-                            throw task.error.error;
-                        // 返回 promise 完成后的数据，没完成则返回 undefined，避免阻塞 mustache 渲染
-                        return task.result?.data;
-                    };
-                });
-                const render = async () => controller.enqueue(await renderMessage(template, ctx, { escapeJsonSymbols: true }));
-                await render();
-                // wait for all promise in the queue to be resolved
-                await Promise.race([queue.drained(), errorPromise]);
-            }
-            catch (error) {
-                controller.error(error);
-            }
-            controller.close();
-        },
-    });
-}

package/lib/esm/types/assistant/mustache/directive.js

@@ -1,29 +0,0 @@
-import Mustache from './mustache';
-export function parseDirectives(...content) {
-    return content.flatMap((content) => {
-        // 捕获 api/{{var/api/task/{{list}} 这种错误
-        try {
-            const spans = Mustache.parse(content);
-            const directives = [];
-            for (const span of spans) {
-                switch (span[0]) {
-                    case 'name': {
-                        const name = span[1];
-                        if (name)
-                            directives.push({ type: 'variable', name });
-                        break;
-                    }
-                    case 'text': {
-                        break;
-                    }
-                    default:
-                        console.warn('Unknown directive', span);
-                }
-            }
-            return directives;
-        }
-        catch (error) {
-            return [];
-        }
-    });
-}