@aigne/core 0.4.201-5 → 0.4.201-7

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

@@ -1,47 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaToDataType = SchemaToDataType;
+exports.schemaToDataType = schemaToDataType;
 const nanoid_1 = require("nanoid");
 const utils_1 = require("./utils");
-function SchemaToDataType(dataType) {
+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 {
-                    id: (0, nanoid_1.nanoid)(),
-                    name,
+                    ...base,
                     type: 'string',
-                    required: schema.required,
                 };
             case 'number':
                 return {
-                    id: (0, nanoid_1.nanoid)(),
-                    name,
+                    ...base,
                     type: 'number',
-                    required: schema.required,
                 };
             case 'boolean':
                 return {
-                    id: (0, nanoid_1.nanoid)(),
-                    name,
+                    ...base,
                     type: 'boolean',
-                    required: schema.required,
                 };
             case 'object':
                 return {
-                    id: (0, nanoid_1.nanoid)(),
-                    name,
+                    ...base,
                     type: 'object',
-                    required: schema.required,
-                    properties: SchemaToDataType(schema.properties),
+                    properties: schemaToDataType(schema.properties),
                 };
             case 'array':
                 return {
-                    id: (0, nanoid_1.nanoid)(),
-                    name,
+                    ...base,
                     type: 'array',
-                    required: schema.required,
-                    items: SchemaToDataType({ items: schema.items })['items'],
+                    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

@@ -62,8 +62,8 @@ function createFunctionAgentDefinition(options) {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,
         type: 'function_agent',
-        inputs: (0, data_type_schema_1.SchemaToDataType)(options.inputs),
-        outputs: (0, data_type_schema_1.SchemaToDataType)(options.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/llm-agent.js

@@ -117,8 +117,8 @@ function createLLMAgentDefinition(options) {
         id: options.id || options.name || (0, nanoid_1.nanoid)(),
         name: options.name,
         type: 'llm_agent',
-        inputs: (0, data_type_schema_1.SchemaToDataType)(options.inputs),
-        outputs: (0, data_type_schema_1.SchemaToDataType)(options.outputs),
+        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)(),

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

@@ -15,11 +15,9 @@ 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");
-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");
@@ -83,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;
@@ -115,7 +94,6 @@ exports.LLMDecisionAgent = LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, llm_model_1.LLMModel, Object])
 ], LLMDecisionAgent);
 function createLLMDecisionAgentDefinition(options) {
-    const inputs = (0, data_type_schema_1.SchemaToDataType)(options.inputs);
     const messages = utils_1.OrderedRecord.fromArray([
         {
             id: (0, nanoid_1.nanoid)(),
@@ -128,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

@@ -58,8 +58,8 @@ exports.LocalFunctionAgent = LocalFunctionAgent = LocalFunctionAgent_1 = __decor
     __metadata("design:paramtypes", [Object, Object])
 ], LocalFunctionAgent);
 function createLocalFunctionAgentDefinition(options) {
-    const inputs = (0, data_type_schema_1.SchemaToDataType)(options.inputs);
-    const outputs = (0, data_type_schema_1.SchemaToDataType)(options.outputs);
+    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

@@ -146,7 +146,7 @@ exports.PipelineAgent = PipelineAgent = PipelineAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
 function createPipelineAgentDefinition(options) {
-    const inputs = (0, data_type_schema_1.SchemaToDataType)(options.inputs);
+    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, {
@@ -177,7 +177,7 @@ function createPipelineAgentDefinition(options) {
             }).filter(is_non_nullable_1.isNonNullable)),
         });
     }
-    const outputs = ordered_map_1.OrderedRecord.fromArray(ordered_map_1.OrderedRecord.map((0, data_type_schema_1.SchemaToDataType)(options.outputs), (output) => {
+    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);