@aigne/core 0.4.209 → 0.4.210

package/lib/cjs/utils/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH_TIMEOUT = void 0;
+exports.FETCH_TIMEOUT = Number(process.env.FETCH_TIMEOUT) || 30000;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOpenApi = void 0;
+const ufo_1 = require("ufo");
+const constants_1 = require("./constants");
+const fetch_1 = require("./fetch");
+const fetchOpenApi = async (request) => {
+    const cookie = request.cookies
+        ? Object.entries(request.cookies)
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('; ')
+            .trim()
+        : undefined;
+    const controller = new AbortController();
+    const abortTimer = setTimeout(() => controller.abort(), constants_1.FETCH_TIMEOUT);
+    const response = await fetch((0, ufo_1.withQuery)(request.url, request.query ?? {}), {
+        method: request.method,
+        headers: {
+            'Content-Type': 'application/json',
+            ...request.headers,
+            ...(cookie && { cookie }),
+        },
+        body: request.method.toLowerCase() !== 'get' && request.body ? JSON.stringify(request.body) : undefined,
+        credentials: request.cookies ? 'include' : 'same-origin',
+        signal: controller.signal,
+    }).finally(() => clearTimeout(abortTimer));
+    await (0, fetch_1.checkFetchResponse)(response);
+    return response.json();
+};
+exports.fetchOpenApi = fetchOpenApi;

package/lib/cjs/utils/fetch.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFetchResponse = checkFetchResponse;
+async function checkFetchResponse(result) {
+    if (!result.ok) {
+        let message;
+        try {
+            const json = await result.json();
+            const msg = json.error?.message || json.message;
+            if (msg && typeof msg === 'string') {
+                message = msg;
+            }
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(message || `Failed to fetch url ${result.url} with status ${result.status}`);
+    }
+    return result;
+}

package/lib/cjs/utils/index.js

@@ -14,10 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetch"), exports);
+__exportStar(require("./fetch-open-api"), exports);
 __exportStar(require("./is-non-nullable"), exports);
 __exportStar(require("./mustache-utils"), exports);
 __exportStar(require("./nullable"), exports);
 __exportStar(require("./omit"), exports);
+__exportStar(require("./open-api-parameter"), exports);
 __exportStar(require("./ordered-map"), exports);
 __exportStar(require("./stream-utils"), exports);
 __exportStar(require("./union"), exports);

package/lib/cjs/utils/open-api-parameter.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOpenAPIRequest = formatOpenAPIRequest;
+const lodash_1 = require("lodash");
+const logger_1 = __importDefault(require("../logger"));
+const ordered_map_1 = require("./ordered-map");
+async function formatOpenAPIRequest(api, inputs, input) {
+    const { url, method, ...inputParams } = processParameters(api, inputs, input);
+    logger_1.default.debug('inputParams', inputParams);
+    const authParams = await getAuthParams(api.auth);
+    logger_1.default.debug('authParams', authParams);
+    return {
+        url,
+        method,
+        ...(0, lodash_1.omitBy)({
+            ...inputParams,
+            query: { ...inputParams.query, ...authParams.query },
+            cookies: { ...inputParams.cookies, ...authParams.cookies },
+            headers: { ...inputParams.headers, ...authParams.headers },
+        }, (i) => (0, lodash_1.isEmpty)(i)),
+    };
+}
+async function getAuthParams(auth) {
+    if (!auth)
+        return {};
+    if (auth.type === 'custom') {
+        return await auth.getValue();
+    }
+    const { type, key, token } = auth;
+    switch (auth.in) {
+        case 'query':
+            return { query: { [key || 'token']: token } };
+        case 'cookie':
+            return { cookies: { [key || 'token']: token } };
+        default: {
+            const prefix = type === 'bearer' ? 'Bearer ' : type === 'basic' ? 'Basic ' : '';
+            return { headers: { [key || 'Authorization']: `${prefix}${token}` } };
+        }
+    }
+}
+function processParameters(api, inputs, input) {
+    const result = {
+        url: api.url,
+        method: api.method,
+        headers: {},
+        query: {},
+        cookies: {},
+        body: {},
+    };
+    Object.entries(input).forEach(([key, value]) => {
+        const schema = ordered_map_1.OrderedRecord.find(inputs, (x) => x.name === key);
+        if (!schema)
+            return;
+        switch (schema.in) {
+            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':
+                result.url = result.url.replace(`{${key}}`, String(value));
+                break;
+            default:
+                // 没有指定 in 的情况
+                if (result.method.toLowerCase() === 'get') {
+                    result.query[key] = value;
+                }
+                else {
+                    result.body[key] = value;
+                }
+        }
+    });
+    return result;
+}

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

@@ -1,5 +1,5 @@
 import { nanoid } from 'nanoid';
-import { OrderedRecord } from '../utils';
+import { OrderedRecord } from '../utils/ordered-map';
 export function schemaToDataType(dataType) {
     return OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
         const base = {

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

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

package/lib/esm/index.js

@@ -2,6 +2,8 @@ export * from './utils';
 export * from './constants';
 export * from './definitions/data-type';
 export * from './definitions/data-type-schema';
+export * from './definitions/open-api';
+export * from './definitions/memory';
 export * from './context';
 export * from './runnable';
 export * from './agent';
@@ -12,4 +14,5 @@ export * from './function-agent';
 export * from './function-runner';
 export * from './llm-decision-agent';
 export * from './local-function-agent';
+export * from './open-api-agent';
 export * from './memorable';

package/lib/esm/open-api-agent.js

@@ -0,0 +1,59 @@
+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 { nanoid } from 'nanoid';
+import { inject, injectable } from 'tsyringe';
+import { Agent } from './agent';
+import { TYPES } from './constants';
+import { schemaToDataType } from './definitions/data-type-schema';
+import { fetchOpenApi } from './utils/fetch-open-api';
+import { formatOpenAPIRequest } from './utils/open-api-parameter';
+let OpenAPIAgent = class OpenAPIAgent extends Agent {
+    definition;
+    static create = create;
+    constructor(definition, context) {
+        super(definition, context);
+        this.definition = definition;
+    }
+    async process(input) {
+        const { url, method = 'get', auth, inputs } = this.definition;
+        if (!url)
+            throw new Error('API url is required');
+        const request = await formatOpenAPIRequest({ url, method, auth }, inputs, input);
+        return this.fetch(request);
+    }
+    fetch(request) {
+        return fetchOpenApi(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: 'open_api_agent',
+        inputs,
+        outputs,
+        url: options.url,
+        method: options.method,
+        auth: options.auth,
+    }, context);
+}