@aigne/core 0.4.205-1 → 0.4.206

package/lib/cjs/pipeline-agent.js

@@ -14,32 +14,26 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var PipelineAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PipelineAgent = void 0;
-exports.createPipelineAgentDefinition = createPipelineAgentDefinition;
 const lodash_1 = require("lodash");
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
+const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
+const memory_1 = require("./definitions/memory");
 const logger_1 = __importDefault(require("./logger"));
-const runnable_1 = require("./runnable");
-const utils_1 = require("./utils");
 const is_non_nullable_1 = require("./utils/is-non-nullable");
 const ordered_map_1 = require("./utils/ordered-map");
-let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Runnable {
+let PipelineAgent = class PipelineAgent extends agent_1.Agent {
     definition;
-    static create(options) {
-        const definition = createPipelineAgentDefinition(options);
-        return new PipelineAgent_1(definition);
-    }
+    static create = create;
     constructor(definition, context) {
         super(definition, context);
         this.definition = definition;
     }
-    async run(input, options) {
-        // TODO: validate the input against the definition
+    async process(input, options) {
         const { definition, context } = this;
         if (!context)
             throw new Error('Context is required');
@@ -47,16 +41,19 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Run
         if (!processes?.$indexes.length) {
             throw new Error('No processes defined');
         }
-        const result = new ReadableStream({
+        return new ReadableStream({
             async start(controller) {
                 try {
                     // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
-                    const variables = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.inputs, (i) => {
-                        const value = input[i.name || i.id];
-                        if ((0, lodash_1.isNil)(value))
-                            return null;
-                        return [i.id, value];
-                    }).filter(is_non_nullable_1.isNonNullable));
+                    const variables = {
+                        ...options.memories,
+                        ...Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.inputs, (i) => {
+                            const value = input[i.name || i.id];
+                            if ((0, lodash_1.isNil)(value))
+                                return null;
+                            return [i.id, value];
+                        }).filter(is_non_nullable_1.isNonNullable)),
+                    };
                     const outputs = ordered_map_1.OrderedRecord.toArray(definition.outputs);
                     const textStreamOutput = outputs.find((i) => i.name === constants_1.StreamTextOutputName);
                     let result = {};
@@ -105,6 +102,8 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Run
                                 result = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.outputs, (output) => {
                                     if (!output.name)
                                         return null;
+                                    if (output.name === constants_1.StreamTextOutputName)
+                                        return null;
                                     let value;
                                     if (output.from === 'variable') {
                                         const v = variables[output.fromVariableId];
@@ -129,30 +128,27 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Run
                 }
             },
         });
-        if (options?.stream) {
-            return result;
-        }
-        // TODO: validate the result against the definition.outputs
-        return await (0, utils_1.runnableResponseStreamToObject)(result);
     }
 };
 exports.PipelineAgent = PipelineAgent;
-exports.PipelineAgent = PipelineAgent = PipelineAgent_1 = __decorate([
+exports.PipelineAgent = PipelineAgent = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
-function createPipelineAgentDefinition(options) {
+function create({ context, ...options }) {
+    const agentId = options.name || (0, nanoid_1.nanoid)();
     const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
+    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
     const processes = ordered_map_1.OrderedRecord.fromArray([]);
-    for (const p of options.processes || []) {
+    for (const [name, p] of Object.entries(options.processes)) {
         ordered_map_1.OrderedRecord.push(processes, {
             id: (0, nanoid_1.nanoid)(),
-            name: p.name || p.runnable?.name,
+            name: name || p.runnable?.name,
             runnable: { id: p.runnable.id },
             input: Object.fromEntries(ordered_map_1.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`);
@@ -163,7 +159,7 @@ function createPipelineAgentDefinition(options) {
                 const inputFromPipeline = ordered_map_1.OrderedRecord.find(inputs, (input) => input.name === i.fromVariable) ||
                     ordered_map_1.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,
                     {
@@ -183,12 +179,13 @@ function createPipelineAgentDefinition(options) {
             throw new Error(`Output ${output.name} not found in inputs or processes`);
         return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
     }));
-    return {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+    return new PipelineAgent({
+        id: agentId,
         name: options.name,
         type: 'pipeline_agent',
         inputs,
+        memories,
         outputs,
         processes,
-    };
+    }, context);
 }

package/lib/cjs/runnable.js

@@ -10,6 +10,7 @@ class Runnable {
     constructor(definition, context) {
         this.definition = definition;
         this.context = context;
+        context?.register(this);
         this.inputs = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.inputs, (i) => [i.name || i.id, i]));
         this.outputs = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.outputs, (i) => [i.name || i.id, i]));
     }