@aigne/core 0.4.201 → 0.4.202

package/lib/cjs/utils/ordered-map.js

@@ -48,6 +48,13 @@ var OrderedRecord;
         return undefined;
     }
     OrderedRecord.find = find;
+    function at(record, index) {
+        if (!record?.$indexes.length)
+            return undefined;
+        const id = record.$indexes.at(index);
+        return record[id];
+    }
+    OrderedRecord.at = at;
     function push(record, ...items) {
         for (const item of items) {
             if (record[item.id])

package/lib/cjs/utils/runnable-type.js

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

package/lib/cjs/utils/union.js

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

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

@@ -0,0 +1,43 @@
+import { nanoid } from 'nanoid';
+import { OrderedRecord } from './utils';
+export function schemaToDataType(dataType) {
+    return OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
+        const base = {
+            ...schema,
+            id: 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: OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                };
+            default: {
+                throw new Error(`Unknown data type: ${schema.type}`);
+            }
+        }
+    }));
+}

package/lib/esm/function-agent.js

@@ -14,9 +14,10 @@ var FunctionAgent_1;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { TYPES } from './constants';
+import { schemaToDataType } from './data-type-schema';
 import { FunctionRunner } from './function-runner';
-import { Runnable, } from './runnable';
-import { OrderedRecord, objectToRunnableResponseStream } from './utils';
+import { Runnable } from './runnable';
+import { objectToRunnableResponseStream } from './utils';
 let FunctionAgent = FunctionAgent_1 = class FunctionAgent extends Runnable {
     definition;
     runner;
@@ -53,24 +54,12 @@ 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: schemaToDataType(options.inputs),
+        outputs: schemaToDataType(options.outputs),
         language: options.language,
         code: options.code,
     };

package/lib/esm/index.js

@@ -1,6 +1,7 @@
 export * from './utils';
 export * from './constants';
 export * from './data-type';
+export * from './data-type-schema';
 export * from './context';
 export * from './runnable';
 export * from './pipeline-agent';

package/lib/esm/llm-agent.js

@@ -15,6 +15,7 @@ import { omitBy } from 'lodash';
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { StreamTextOutputName, TYPES } from './constants';
+import { schemaToDataType } from './data-type-schema';
 import { LLMModel } from './llm-model';
 import { Runnable, } from './runnable';
 import { isNonNullable, isPropsNonNullable } from './utils';
@@ -108,26 +109,18 @@ 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: schemaToDataType(options.inputs),
+        outputs: schemaToDataType(options.outputs),
         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

@@ -11,13 +11,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 var LLMDecisionAgent_1;
-import { get, isNil } from 'lodash';
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { TYPES } from './constants';
 import { LLMModel } from './llm-model';
-import { Runnable, } from './runnable';
-import { OrderedRecord, isNonNullable, renderMessage } from './utils';
+import { Runnable } from './runnable';
+import { OrderedRecord, renderMessage } from './utils';
 let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends Runnable {
     definition;
     model;
@@ -78,27 +77,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(OrderedRecord.map(this.definition.inputs, (i) => {
-            const value = input[i.name || i.id];
-            if (isNil(value))
-                return null;
-            return [i.id, value];
-        }).filter(isNonNullable));
-        const inputForCase = Object.fromEntries(Object.entries(caseToCall.input ?? {})
-            .map(([inputId, { from, fromVariableId, fromVariablePropPath }]) => {
-            const targetInput = 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 ? get(v, fromVariablePropPath) : v;
-            return [targetInput.name, value];
-        })
-            .filter(isNonNullable));
         // TODO: check result structure and omit undefined values
-        return (await caseToCall.runnable.run(inputForCase, options));
+        return (await caseToCall.runnable.run(input, options));
     }
 };
 LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
@@ -110,12 +90,6 @@ LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
 export function createLLMDecisionAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
     const messages = OrderedRecord.fromArray([
         {
             id: nanoid(),
@@ -128,34 +102,13 @@ export 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(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 = 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(isNonNullable)),
     })));
     return {
         id: options.id || options.name || nanoid(),
         name: options.name,
         type: 'llm_decision_agent',
-        inputs,
+        // TODO: decision agent inputs should be the intersection of all case inputs
+        inputs: OrderedRecord.fromArray([]),
         // TODO: decision agent outputs should be the union of all case outputs
         outputs: OrderedRecord.fromArray([]),
         messages,

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

@@ -14,8 +14,9 @@ var LocalFunctionAgent_1;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { TYPES } from './constants';
-import { Runnable, } from './runnable';
-import { OrderedRecord, objectToRunnableResponseStream, runnableResponseStreamToObject } from './utils';
+import { schemaToDataType } from './data-type-schema';
+import { Runnable } from './runnable';
+import { objectToRunnableResponseStream, runnableResponseStreamToObject } from './utils';
 let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends Runnable {
     definition;
     context;
@@ -53,18 +54,8 @@ LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
 ], LocalFunctionAgent);
 export { LocalFunctionAgent };
 export function createLocalFunctionAgentDefinition(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,
-    })));
+    const inputs = schemaToDataType(options.inputs);
+    const outputs = schemaToDataType(options.outputs);
     return {
         id: options.id || options.name || nanoid(),
         name: options.name,

package/lib/esm/pipeline-agent.js

@@ -15,6 +15,7 @@ import { get, isNil } from 'lodash';
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { StreamTextOutputName, TYPES } from './constants';
+import { schemaToDataType } from './data-type-schema';
 import logger from './logger';
 import { Runnable, } from './runnable';
 import { runnableResponseStreamToObject } from './utils';
@@ -138,12 +139,7 @@ PipelineAgent = PipelineAgent_1 = __decorate([
 ], PipelineAgent);
 export { PipelineAgent };
 export function createPipelineAgentDefinition(options) {
-    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
-        id: nanoid(),
-        name: i.name,
-        type: i.type,
-        required: i.required,
-    })));
+    const inputs = schemaToDataType(options.inputs);
     const processes = OrderedRecord.fromArray([]);
     for (const p of options.processes || []) {
         OrderedRecord.push(processes, {
@@ -174,20 +170,13 @@ 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(OrderedRecord.map(schemaToDataType(options.outputs), (output) => {
+        const { fromVariable, fromVariablePropPath } = options.outputs[output.name];
+        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`);
-        return {
-            id: 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 || nanoid(),