@aigne/core 0.4.201 → 0.4.202

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/function-agent.js

@@ -18,6 +18,7 @@ exports.createFunctionAgentDefinition = createFunctionAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
+const data_type_schema_1 = require("./data-type-schema");
 const function_runner_1 = require("./function-runner");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
@@ -57,24 +58,12 @@ exports.FunctionAgent = FunctionAgent = FunctionAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, function_runner_1.FunctionRunner])
 ], FunctionAgent);
 function createFunctionAgentDefinition(options) {
-    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
-    const outputs = utils_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
     return {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,
         type: 'function_agent',
-        inputs,
-        outputs,
+        inputs: (0, data_type_schema_1.schemaToDataType)(options.inputs),
+        outputs: (0, data_type_schema_1.schemaToDataType)(options.outputs),
         language: options.language,
         code: options.code,
     };

package/lib/cjs/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./data-type"), exports);
+__exportStar(require("./data-type-schema"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./runnable"), exports);
 __exportStar(require("./pipeline-agent"), exports);

package/lib/cjs/llm-agent.js

@@ -19,6 +19,7 @@ const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
+const data_type_schema_1 = require("./data-type-schema");
 const llm_model_1 = require("./llm-model");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
@@ -112,26 +113,18 @@ exports.LLMAgent = LLMAgent = LLMAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, llm_model_1.LLMModel])
 ], LLMAgent);
 function createLLMAgentDefinition(options) {
-    const inputs = ordered_map_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
-    const outputs = ordered_map_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({ ...i, id: (0, nanoid_1.nanoid)() })));
-    const messages = ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        role: i.role,
-        content: i.content,
-    })));
     return {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,
         type: 'llm_agent',
-        inputs,
-        outputs,
-        messages,
+        inputs: (0, data_type_schema_1.schemaToDataType)(options.inputs),
+        outputs: (0, data_type_schema_1.schemaToDataType)(options.outputs),
         modelOptions: options.modelOptions,
+        messages: ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
+            id: (0, nanoid_1.nanoid)(),
+            role: i.role,
+            content: i.content,
+        }))),
     };
 }
 function outputsToJsonSchema(outputs) {

package/lib/cjs/llm-decision-agent.js

@@ -15,7 +15,6 @@ var LLMDecisionAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMDecisionAgent = void 0;
 exports.createLLMDecisionAgentDefinition = createLLMDecisionAgentDefinition;
-const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
@@ -82,27 +81,8 @@ let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends runna
         const caseToCall = cases.find((i) => i.name === functionNameToCall);
         if (!caseToCall)
             throw new Error('Case not found');
-        // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
-        const variables = Object.fromEntries(utils_1.OrderedRecord.map(this.definition.inputs, (i) => {
-            const value = input[i.name || i.id];
-            if ((0, lodash_1.isNil)(value))
-                return null;
-            return [i.id, value];
-        }).filter(utils_1.isNonNullable));
-        const inputForCase = Object.fromEntries(Object.entries(caseToCall.input ?? {})
-            .map(([inputId, { from, fromVariableId, fromVariablePropPath }]) => {
-            const targetInput = utils_1.OrderedRecord.find(caseToCall.runnable.definition.inputs, (i) => i.id === inputId);
-            if (!targetInput?.name)
-                return null;
-            if (from !== 'variable' || !fromVariableId)
-                return null;
-            const v = variables[fromVariableId];
-            const value = fromVariablePropPath?.length ? (0, lodash_1.get)(v, fromVariablePropPath) : v;
-            return [targetInput.name, value];
-        })
-            .filter(utils_1.isNonNullable));
         // TODO: check result structure and omit undefined values
-        return (await caseToCall.runnable.run(inputForCase, options));
+        return (await caseToCall.runnable.run(input, options));
     }
 };
 exports.LLMDecisionAgent = LLMDecisionAgent;
@@ -114,12 +94,6 @@ exports.LLMDecisionAgent = LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, llm_model_1.LLMModel, Object])
 ], LLMDecisionAgent);
 function createLLMDecisionAgentDefinition(options) {
-    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
     const messages = utils_1.OrderedRecord.fromArray([
         {
             id: (0, nanoid_1.nanoid)(),
@@ -132,34 +106,13 @@ function createLLMDecisionAgentDefinition(options) {
         name: c.name || c.runnable.name,
         description: c.description,
         runnable: { id: c.runnable.id },
-        // TODO: pass input from decision to case runnable
-        input: Object.fromEntries(utils_1.OrderedRecord.map(c.runnable.definition.inputs, (inputOfCase) => {
-            const i = c.input?.[inputOfCase.name || inputOfCase.id];
-            if (!i) {
-                if (inputOfCase.required) {
-                    throw new Error(`Input ${inputOfCase.name || inputOfCase.id} for case ${c.runnable.name || c.runnable.id} is required`);
-                }
-                // ignore optional input
-                return null;
-            }
-            const inputFromDecision = utils_1.OrderedRecord.find(inputs, (input) => input.name === i.fromVariable);
-            if (!inputFromDecision)
-                throw new Error(`Input ${i.fromVariable} not found`);
-            return [
-                inputOfCase.id,
-                {
-                    from: 'variable',
-                    fromVariableId: inputFromDecision.id,
-                    fromVariablePropPath: i.fromVariablePropPath,
-                },
-            ];
-        }).filter(utils_1.isNonNullable)),
     })));
     return {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,
         type: 'llm_decision_agent',
-        inputs,
+        // TODO: decision agent inputs should be the intersection of all case inputs
+        inputs: utils_1.OrderedRecord.fromArray([]),
         // TODO: decision agent outputs should be the union of all case outputs
         outputs: utils_1.OrderedRecord.fromArray([]),
         messages,

package/lib/cjs/local-function-agent.js

@@ -18,6 +18,7 @@ exports.createLocalFunctionAgentDefinition = createLocalFunctionAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
+const data_type_schema_1 = require("./data-type-schema");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
 let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends runnable_1.Runnable {
@@ -57,18 +58,8 @@ exports.LocalFunctionAgent = LocalFunctionAgent = LocalFunctionAgent_1 = __decor
     __metadata("design:paramtypes", [Object, Object])
 ], LocalFunctionAgent);
 function createLocalFunctionAgentDefinition(options) {
-    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
-    const outputs = utils_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
+    const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
+    const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
     return {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,

package/lib/cjs/pipeline-agent.js

@@ -22,6 +22,7 @@ const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
+const data_type_schema_1 = require("./data-type-schema");
 const logger_1 = __importDefault(require("./logger"));
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
@@ -145,12 +146,7 @@ exports.PipelineAgent = PipelineAgent = PipelineAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
 function createPipelineAgentDefinition(options) {
-    const inputs = ordered_map_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
+    const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
     const processes = ordered_map_1.OrderedRecord.fromArray([]);
     for (const p of options.processes || []) {
         ordered_map_1.OrderedRecord.push(processes, {
@@ -181,20 +177,13 @@ function createPipelineAgentDefinition(options) {
             }).filter(is_non_nullable_1.isNonNullable)),
         });
     }
-    const outputs = ordered_map_1.OrderedRecord.fromArray(options.outputs.map((output) => {
-        const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === output.fromVariable) ||
-            ordered_map_1.OrderedRecord.find(processes, (p) => p.name === output.fromVariable);
+    const outputs = ordered_map_1.OrderedRecord.fromArray(ordered_map_1.OrderedRecord.map((0, data_type_schema_1.schemaToDataType)(options.outputs), (output) => {
+        const { fromVariable, fromVariablePropPath } = options.outputs[output.name];
+        const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === fromVariable) ||
+            ordered_map_1.OrderedRecord.find(processes, (p) => p.name === fromVariable);
         if (!from)
             throw new Error(`Output ${output.name} not found in inputs or processes`);
-        return {
-            id: (0, nanoid_1.nanoid)(),
-            name: output.name,
-            type: output.type,
-            required: output.required,
-            from: 'variable',
-            fromVariableId: from.id,
-            fromVariablePropPath: output.fromVariablePropPath,
-        };
+        return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
     }));
     return {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),