@aigne/core 0.4.211-beta.2 → 1.0.0

package/lib/cjs/utils/fetch-api.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchApi = void 0;
-const ufo_1 = require("ufo");
-const constants_1 = require("./constants");
-const fetchApi = async (request) => {
-    let cookieString = '';
-    if (request.cookies) {
-        cookieString = Object.entries(request.cookies)
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('; ');
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), Number(constants_1.TIMEOUT));
-    const response = await fetch((0, ufo_1.withQuery)(request.url, request.query || {}), {
-        method: request.method,
-        headers: {
-            'Content-Type': 'application/json',
-            ...(cookieString && { Cookie: cookieString.trim() }),
-            ...request.headers,
-        },
-        body: request.method !== 'GET' ? JSON.stringify(request.body) : undefined,
-        credentials: request.cookies ? 'include' : 'same-origin',
-        signal: controller.signal,
-    }).finally(() => clearTimeout(timeoutId));
-    if (!response.ok) {
-        const errorBody = await response.text();
-        throw new Error(`API request failed for ${request.url}\n` +
-            `Status: ${response.status} ${response.statusText}\n` +
-            `Response: ${errorBody.slice(0, 200)}`);
-    }
-    return response.json();
-};
-exports.fetchApi = fetchApi;
-exports.default = exports.fetchApi;

package/lib/cjs/utils/flatten-openapi.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenApiStructure = flattenApiStructure;
-function flattenApiStructure(apiStructure) {
-    const paths = apiStructure?.paths || {};
-    return Object.entries(paths).flatMap(([, methods]) => Object.entries(methods).map(([, endpoint]) => ({
-        id: endpoint['x-id'],
-        name: endpoint['x-did'],
-        path: endpoint['x-path'],
-        method: endpoint['x-method'],
-        did: endpoint['x-did'],
-        ...endpoint,
-    })));
-}

package/lib/cjs/utils/format-parameter.js

@@ -1,126 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatRequest = void 0;
-exports.getAuthParams = getAuthParams;
-exports.processParameters = processParameters;
-exports.mergeParameters = mergeParameters;
-const logger_1 = __importDefault(require("../logger"));
-function getAuthParams(auth) {
-    if (!auth)
-        return {};
-    if (auth.type === 'custom') {
-        return { headers: auth.getValue() };
-    }
-    const paramKey = auth.key || 'Authorization';
-    const paramValue = (() => {
-        let paramValue = auth.token;
-        switch (auth.type) {
-            case 'basic':
-                paramValue = `Basic ${auth.token}`;
-                break;
-            case 'bearer':
-                paramValue = `Bearer ${auth.token}`;
-                break;
-            default:
-                break;
-        }
-        return paramValue;
-    })();
-    switch (auth.in) {
-        case 'header':
-            return { headers: { [paramKey]: paramValue } };
-        case 'query':
-            return { query: { [paramKey]: paramValue } };
-        case 'cookie':
-            return { cookies: { [paramKey]: paramValue } };
-        default:
-            // 默认放在 header 中
-            return { headers: { [paramKey]: paramValue } };
-    }
-}
-function processParameters(api, inputs, input) {
-    const method = (api.method || 'GET').toUpperCase();
-    const result = {
-        url: api.url,
-        method,
-        headers: {},
-        query: {},
-        cookies: {},
-        body: {},
-    };
-    const filterInputs = Object.values(inputs).filter((i) => !Array.isArray(i));
-    // 处理路径参数
-    let processedUrl = api.url;
-    const pathParams = filterInputs.filter((x) => x.in === 'path');
-    pathParams.forEach(({ name }) => {
-        if (name && input[name] !== undefined) {
-            const placeholder = `{${name}}`;
-            processedUrl = processedUrl.replace(placeholder, String(input[name]));
-        }
-    });
-    result.url = processedUrl;
-    // 处理其他参数
-    Object.entries(input).forEach(([key, value]) => {
-        const schema = filterInputs.find((i) => i.name === key);
-        const paramIn = schema?.in;
-        switch (paramIn) {
-            case 'query':
-                result.query[key] = value;
-                break;
-            case 'header':
-                result.headers[key] = value;
-                break;
-            case 'cookie':
-                result.cookies[key] = value;
-                break;
-            case 'body':
-                result.body[key] = value;
-                break;
-            case 'path':
-                break;
-            default:
-                // 没有指定 in 的情况
-                if (method === 'GET') {
-                    result.query[key] = value;
-                }
-                else {
-                    result.body[key] = value;
-                }
-        }
-    });
-    return result;
-}
-function mergeParameters(parameters, authParams) {
-    const result = {};
-    if (parameters.query || authParams.query) {
-        result.query = { ...(parameters.query || {}), ...(authParams.query || {}) };
-    }
-    if (parameters.cookies || authParams.cookies) {
-        result.cookies = { ...(parameters.cookies || {}), ...(authParams.cookies || {}) };
-    }
-    if (parameters.headers || authParams.headers) {
-        result.headers = { ...(parameters.headers || {}), ...(authParams.headers || {}) };
-    }
-    return result;
-}
-const formatRequest = (api, inputs, input) => {
-    const inputParams = processParameters(api, inputs, input);
-    logger_1.default.debug('inputParams', inputParams);
-    const authParams = getAuthParams(api.auth);
-    logger_1.default.debug('authParams', authParams);
-    const mergedParams = mergeParameters(inputParams, authParams);
-    logger_1.default.debug('mergedParams', mergedParams);
-    const params = { ...inputParams, ...mergedParams };
-    return {
-        url: params.url,
-        method: params.method,
-        ...(params.headers && Object.keys(params.headers).length > 0 && { headers: params.headers }),
-        ...(params.query && Object.keys(params.query).length > 0 && { query: params.query }),
-        ...(params.cookies && Object.keys(params.cookies).length > 0 && { cookies: params.cookies }),
-        ...(params.body && Object.keys(params.body).length > 0 && { body: params.body }),
-    };
-};
-exports.formatRequest = formatRequest;

package/lib/esm/api-agent.js

@@ -1,67 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { pick } from 'lodash';
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { TYPES } from './constants';
-import { schemaToDataType } from './definitions/data-type-schema';
-import { fetchApi } from './utils/fetch-api';
-import { formatRequest } from './utils/format-parameter';
-let OpenAPIAgent = class OpenAPIAgent extends Agent {
-    definition;
-    static create = create;
-    constructor(definition, context) {
-        super(definition, context);
-        this.definition = definition;
-    }
-    async process(input) {
-        const { definition: { url, method, auth, inputs }, context, } = this;
-        if (!url)
-            throw new Error('API url is required');
-        const api = {
-            url,
-            method,
-            auth,
-        };
-        const request = formatRequest(api, inputs, input);
-        const contextState = pick(context?.state, ['userId', 'sessionId']);
-        request.query = { ...contextState, ...(request.query || {}) };
-        return this.fetch(request);
-    }
-    fetch(request) {
-        return fetchApi(request);
-    }
-};
-OpenAPIAgent = __decorate([
-    injectable(),
-    __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, Object])
-], OpenAPIAgent);
-export { OpenAPIAgent };
-function create({ context, ...options }) {
-    const agentId = options.id || options.name || nanoid();
-    const inputs = schemaToDataType(options.inputs);
-    const outputs = schemaToDataType(options.outputs);
-    return new OpenAPIAgent({
-        id: agentId,
-        name: options.name,
-        type: 'api_agent',
-        inputs,
-        outputs,
-        url: options.url,
-        method: options.method,
-        auth: options.auth,
-    }, context);
-}

package/lib/esm/data-type-schema.js

@@ -1,43 +0,0 @@
-import { nanoid } from 'nanoid';
-import { OrderedRecord } from './utils';
-export function schemaToDataType(dataType) {
-    return OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
-        const base = {
-            ...schema,
-            id: nanoid(),
-            name,
-        };
-        switch (schema.type) {
-            case 'string':
-                return {
-                    ...base,
-                    type: 'string',
-                };
-            case 'number':
-                return {
-                    ...base,
-                    type: 'number',
-                };
-            case 'boolean':
-                return {
-                    ...base,
-                    type: 'boolean',
-                };
-            case 'object':
-                return {
-                    ...base,
-                    type: 'object',
-                    properties: schemaToDataType(schema.properties),
-                };
-            case 'array':
-                return {
-                    ...base,
-                    type: 'array',
-                    items: OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
-                };
-            default: {
-                throw new Error(`Unknown data type: ${schema.type}`);
-            }
-        }
-    }));
-}

package/lib/esm/data-type.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/definitions/api-parameter.js

@@ -1,7 +0,0 @@
-export var HTTPMethod;
-(function (HTTPMethod) {
-    HTTPMethod["GET"] = "GET";
-    HTTPMethod["POST"] = "POST";
-    HTTPMethod["PUT"] = "PUT";
-    HTTPMethod["DELETE"] = "DELETE";
-})(HTTPMethod || (HTTPMethod = {}));

package/lib/esm/memory.js

@@ -1,27 +0,0 @@
-import { camelCase, startCase } from 'lodash';
-import { Runnable } from './runnable';
-import { OrderedRecord } from './utils';
-export class Memory extends Runnable {
-    constructor() {
-        super({
-            id: 'memory',
-            type: 'memory',
-            name: 'Memory',
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        });
-    }
-}
-export class MemoryRunner extends Runnable {
-    constructor(name) {
-        const id = `${camelCase(name)}_runner`;
-        super({
-            id,
-            type: id,
-            name: `${startCase(name)} Runner`,
-            description: `${startCase(name)} Runner`,
-            inputs: OrderedRecord.fromArray([]),
-            outputs: OrderedRecord.fromArray([]),
-        });
-    }
-}