@aigne/core 0.4.205-0 → 0.4.205

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

@@ -13,29 +13,28 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var LocalFunctionAgent_1;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
+import { Agent } from './agent';
 import { TYPES } from './constants';
-import { schemaToDataType } from './data-type-schema';
-import { Runnable } from './runnable';
+import { schemaToDataType } from './definitions/data-type-schema';
+import { toRunnableMemories } from './definitions/memory';
 import { objectToRunnableResponseStream, runnableResponseStreamToObject } from './utils';
-let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends Runnable {
+let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends Agent {
     definition;
-    context;
     static create(options) {
         const definition = createLocalFunctionAgentDefinition(options);
         return new LocalFunctionAgent_1(definition);
     }
     constructor(definition, context) {
-        super(definition);
+        super(definition, context);
         this.definition = definition;
-        this.context = context;
     }
-    async run(input, options) {
+    async process(input, options) {
         const { definition: { function: func }, context, } = this;
         if (!func)
             throw new Error('Function is required');
         if (!context)
             throw new Error('Context is required');
-        const result = (await func(input, { context }));
+        const result = await func(input, { context, memories: options.memories });
         // TODO: validate the result against the definition.outputs
         return options?.stream
             ? result instanceof ReadableStream
@@ -54,14 +53,17 @@ LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
 ], LocalFunctionAgent);
 export { LocalFunctionAgent };
 export function createLocalFunctionAgentDefinition(options) {
+    const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     return {
-        id: options.id || options.name || nanoid(),
+        id: agentId,
         name: options.name,
         type: 'local_function_agent',
         inputs,
         outputs,
+        memories,
         function: options.function,
     };
 }

package/lib/esm/pipeline-agent.js

@@ -14,26 +14,25 @@ var PipelineAgent_1;
 import { get, isNil } from 'lodash';
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
+import { Agent } from './agent';
 import { StreamTextOutputName, TYPES } from './constants';
-import { schemaToDataType } from './data-type-schema';
+import { schemaToDataType } from './definitions/data-type-schema';
+import { toRunnableMemories } from './definitions/memory';
 import logger from './logger';
-import { Runnable, } from './runnable';
 import { runnableResponseStreamToObject } from './utils';
 import { isNonNullable } from './utils/is-non-nullable';
 import { OrderedRecord } from './utils/ordered-map';
-let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Runnable {
+let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Agent {
     definition;
-    context;
     static create(options) {
         const definition = createPipelineAgentDefinition(options);
         return new PipelineAgent_1(definition);
     }
     constructor(definition, context) {
-        super(definition);
+        super(definition, context);
         this.definition = definition;
-        this.context = context;
     }
-    async run(input, options) {
+    async process(input, options) {
         // TODO: validate the input against the definition
         const { definition, context } = this;
         if (!context)
@@ -46,12 +45,15 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Runnable {
             async start(controller) {
                 try {
                     // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
-                    const variables = Object.fromEntries(OrderedRecord.map(definition.inputs, (i) => {
-                        const value = input[i.name || i.id];
-                        if (isNil(value))
-                            return null;
-                        return [i.id, value];
-                    }).filter(isNonNullable));
+                    const variables = {
+                        ...options.memories,
+                        ...Object.fromEntries(OrderedRecord.map(definition.inputs, (i) => {
+                            const value = input[i.name || i.id];
+                            if (isNil(value))
+                                return null;
+                            return [i.id, value];
+                        }).filter(isNonNullable)),
+                    };
                     const outputs = OrderedRecord.toArray(definition.outputs);
                     const textStreamOutput = outputs.find((i) => i.name === StreamTextOutputName);
                     let result = {};
@@ -139,15 +141,17 @@ PipelineAgent = PipelineAgent_1 = __decorate([
 ], PipelineAgent);
 export { PipelineAgent };
 export function createPipelineAgentDefinition(options) {
+    const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
+    const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     const processes = OrderedRecord.fromArray([]);
-    for (const p of options.processes || []) {
+    for (const [name, p] of Object.entries(options.processes)) {
         OrderedRecord.push(processes, {
             id: nanoid(),
-            name: p.name || p.runnable?.name,
+            name: name || p.runnable?.name,
             runnable: { id: p.runnable.id },
             input: Object.fromEntries(OrderedRecord.map(p.runnable.definition.inputs, (inputOfProcess) => {
-                const i = p.input?.[inputOfProcess.name || inputOfProcess.id];
+                const i = p.input[inputOfProcess.name || inputOfProcess.id];
                 if (!i) {
                     if (inputOfProcess.required) {
                         throw new Error(`Input ${inputOfProcess.name || inputOfProcess.id} for case ${p.runnable.name || p.runnable.id} is required`);
@@ -158,7 +162,7 @@ export function createPipelineAgentDefinition(options) {
                 const inputFromPipeline = OrderedRecord.find(inputs, (input) => input.name === i.fromVariable) ||
                     OrderedRecord.find(processes, (p) => p.name === i.fromVariable);
                 if (!inputFromPipeline)
-                    throw new Error(`Input ${i.fromVariable} not found`);
+                    throw new Error(`Input ${i.fromVariable.toString()} not found`);
                 return [
                     inputOfProcess.id,
                     {
@@ -179,10 +183,11 @@ export function createPipelineAgentDefinition(options) {
         return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
     }));
     return {
-        id: options.id || options.name || nanoid(),
+        id: agentId,
         name: options.name,
         type: 'pipeline_agent',
         inputs,
+        memories,
         outputs,
         processes,
     };

package/lib/esm/runnable.js

@@ -1,8 +1,10 @@
 import { OrderedRecord } from './utils/ordered-map';
 export class Runnable {
     definition;
-    constructor(definition) {
+    context;
+    constructor(definition, context) {
         this.definition = definition;
+        this.context = context;
         this.inputs = Object.fromEntries(OrderedRecord.map(definition.inputs, (i) => [i.name || i.id, i]));
         this.outputs = Object.fromEntries(OrderedRecord.map(definition.outputs, (i) => [i.name || i.id, i]));
     }