@aigne/core 0.4.199 → 0.4.201-0

package/lib/esm/function-agent.js

@@ -15,7 +15,7 @@ import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { TYPES } from './constants';
 import { FunctionRunner } from './function-runner';
-import { Runnable, } from './runnable';
+import { Runnable } from './runnable';
 import { OrderedRecord, objectToRunnableResponseStream } from './utils';
 let FunctionAgent = FunctionAgent_1 = class FunctionAgent extends Runnable {
     definition;
@@ -53,24 +53,20 @@ FunctionAgent = FunctionAgent_1 = __decorate([
 ], FunctionAgent);
 export { FunctionAgent };
 export function createFunctionAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
-    const outputs = OrderedRecord.fromArray(options.outputs?.map((i) => ({
-        id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
     return {
         id: options.id || options.name || nanoid(),
         name: options.name,
         type: 'function_agent',
-        inputs,
-        outputs,
+        inputs: OrderedRecord.fromArray(Object.entries(options.inputs).map(([name, { ...dataType }]) => ({
+            ...dataType,
+            id: nanoid(),
+            name,
+        }))),
+        outputs: OrderedRecord.fromArray(Object.entries(options.outputs).map(([name, { ...dataType }]) => ({
+            ...dataType,
+            id: nanoid(),
+            name,
+        }))),
         language: options.language,
         code: options.code,
     };

package/lib/esm/llm-agent.js

@@ -108,26 +108,26 @@ LLMAgent = LLMAgent_1 = __decorate([
 ], LLMAgent);
 export { LLMAgent };
 export function createLLMAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
-    const outputs = OrderedRecord.fromArray(options.outputs?.map((i) => ({ ...i, id: nanoid() })));
-    const messages = OrderedRecord.fromArray(options.messages?.map((i) => ({
-        id: nanoid(),
-        role: i.role,
-        content: i.content,
-    })));
     return {
         id: options.id || options.name || nanoid(),
         name: options.name,
         type: 'llm_agent',
-        inputs,
-        outputs,
-        messages,
+        inputs: OrderedRecord.fromArray(Object.entries(options.inputs).map(([name, { ...dataType }]) => ({
+            ...dataType,
+            id: nanoid(),
+            name,
+        }))),
+        outputs: OrderedRecord.fromArray(Object.entries(options.outputs).map(([name, { ...dataType }]) => ({
+            ...dataType,
+            id: nanoid(),
+            name,
+        }))),
         modelOptions: options.modelOptions,
+        messages: OrderedRecord.fromArray(options.messages?.map((i) => ({
+            id: nanoid(),
+            role: i.role,
+            content: i.content,
+        }))),
     };
 }
 function outputsToJsonSchema(outputs) {

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

@@ -110,11 +110,10 @@ LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
 export function createLLMDecisionAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
+    const inputs = OrderedRecord.fromArray(Object.entries(options.inputs).map(([name, { ...dataType }]) => ({
+        ...dataType,
         id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
+        name: name,
     })));
     const messages = OrderedRecord.fromArray([
         {

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

@@ -53,17 +53,15 @@ LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
 ], LocalFunctionAgent);
 export { LocalFunctionAgent };
 export function createLocalFunctionAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
+    const inputs = OrderedRecord.fromArray(Object.entries(options.inputs).map(([name, i]) => ({
+        ...i,
         id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
+        name,
     })));
-    const outputs = OrderedRecord.fromArray(options.outputs?.map((i) => ({
+    const outputs = OrderedRecord.fromArray(Object.entries(options.outputs).map(([name, o]) => ({
+        ...o,
         id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
+        name,
     })));
     return {
         id: options.id || options.name || nanoid(),

package/lib/esm/pipeline-agent.js

@@ -138,11 +138,10 @@ PipelineAgent = PipelineAgent_1 = __decorate([
 ], PipelineAgent);
 export { PipelineAgent };
 export function createPipelineAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
+    const inputs = OrderedRecord.fromArray(Object.entries(options.inputs).map(([name, { ...dataType }]) => ({
+        ...dataType,
         id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
+        name,
     })));
     const processes = OrderedRecord.fromArray([]);
     for (const p of options.processes || []) {
@@ -174,19 +173,17 @@ export function createPipelineAgentDefinition(options) {
             }).filter(isNonNullable)),
         });
     }
-    const outputs = OrderedRecord.fromArray(options.outputs.map((output) => {
-        const from = OrderedRecord.find(inputs, (i) => i.name === output.fromVariable) ||
-            OrderedRecord.find(processes, (p) => p.name === output.fromVariable);
+    const outputs = OrderedRecord.fromArray(Object.entries(options.outputs).map(([name, { fromVariable, ...output }]) => {
+        const from = OrderedRecord.find(inputs, (i) => i.name === fromVariable) ||
+            OrderedRecord.find(processes, (p) => p.name === fromVariable);
         if (!from)
-            throw new Error(`Output ${output.name} not found in inputs or processes`);
+            throw new Error(`Output ${name} not found in inputs or processes`);
         return {
+            ...output,
             id: nanoid(),
-            name: output.name,
-            type: output.type,
-            required: output.required,
+            name,
             from: 'variable',
             fromVariableId: from.id,
-            fromVariablePropPath: output.fromVariablePropPath,
         };
     }));
     return {