@aigne/core 0.4.210 → 0.4.211-beta.2

package/lib/cjs/api-agent.js

@@ -0,0 +1,70 @@
+"use strict";
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPIAgent = void 0;
+const lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const agent_1 = require("./agent");
+const constants_1 = require("./constants");
+const data_type_schema_1 = require("./definitions/data-type-schema");
+const fetch_api_1 = require("./utils/fetch-api");
+const format_parameter_1 = require("./utils/format-parameter");
+let OpenAPIAgent = class OpenAPIAgent extends agent_1.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 = (0, format_parameter_1.formatRequest)(api, inputs, input);
+        const contextState = (0, lodash_1.pick)(context?.state, ['userId', 'sessionId']);
+        request.query = { ...contextState, ...(request.query || {}) };
+        return this.fetch(request);
+    }
+    fetch(request) {
+        return (0, fetch_api_1.fetchApi)(request);
+    }
+};
+exports.OpenAPIAgent = OpenAPIAgent;
+exports.OpenAPIAgent = OpenAPIAgent = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
+    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
+    __metadata("design:paramtypes", [Object, Object])
+], OpenAPIAgent);
+function create({ context, ...options }) {
+    const agentId = options.id || options.name || (0, nanoid_1.nanoid)();
+    const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
+    const outputs = (0, data_type_schema_1.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/cjs/data-type-schema.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaToDataType = schemaToDataType;
+const nanoid_1 = require("nanoid");
+const utils_1 = require("./utils");
+function schemaToDataType(dataType) {
+    return utils_1.OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
+        const base = {
+            ...schema,
+            id: (0, nanoid_1.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: utils_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                };
+            default: {
+                throw new Error(`Unknown data type: ${schema.type}`);
+            }
+        }
+    }));
+}

package/lib/cjs/data-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPMethod = void 0;
+var HTTPMethod;
+(function (HTTPMethod) {
+    HTTPMethod["GET"] = "GET";
+    HTTPMethod["POST"] = "POST";
+    HTTPMethod["PUT"] = "PUT";
+    HTTPMethod["DELETE"] = "DELETE";
+})(HTTPMethod || (exports.HTTPMethod = HTTPMethod = {}));

package/lib/cjs/memory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRunner = exports.Memory = void 0;
+const lodash_1 = require("lodash");
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class Memory extends runnable_1.Runnable {
+    constructor() {
+        super({
+            id: 'memory',
+            type: 'memory',
+            name: 'Memory',
+            inputs: utils_1.OrderedRecord.fromArray([]),
+            outputs: utils_1.OrderedRecord.fromArray([]),
+        });
+    }
+}
+exports.Memory = Memory;
+class MemoryRunner extends runnable_1.Runnable {
+    constructor(name) {
+        const id = `${(0, lodash_1.camelCase)(name)}_runner`;
+        super({
+            id,
+            type: id,
+            name: `${(0, lodash_1.startCase)(name)} Runner`,
+            description: `${(0, lodash_1.startCase)(name)} Runner`,
+            inputs: utils_1.OrderedRecord.fromArray([]),
+            outputs: utils_1.OrderedRecord.fromArray([]),
+        });
+    }
+}
+exports.MemoryRunner = MemoryRunner;