@aigne/core 0.4.205-1 → 0.4.205

package/lib/cjs/agent.js

@@ -24,18 +24,23 @@ class Agent extends runnable_1.Runnable {
      * Load memories that are defined in the agent definition.
      * @param input The agent input.
      * @param context The AIGNE context.
-     * @returns A dictionary of memories, where the key is the memory name and the value is an array of memory items.
+     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
      */
     async loadMemories(input, context) {
         const { memories } = this.definition;
         const { userId, sessionId } = context?.state ?? {};
-        return Object.fromEntries((await Promise.all(utils_1.OrderedRecord.map(memories, async ({ name, memory, query, options }) => {
+        return Object.fromEntries((await Promise.all(utils_1.OrderedRecord.map(memories, async ({ id, name, memory, query, options }) => {
             if (!name || !memory)
                 return null;
             const q = await this.getMemoryQuery(input, query);
             const { results: memories } = await memory.search(q, { ...options, userId, sessionId });
-            return [name, memories];
-        }))).filter(utils_1.isNonNullable));
+            return [
+                [id, memories],
+                [name, memories],
+            ];
+        })))
+            .flat()
+            .filter(utils_1.isNonNullable));
     }
     /**
      * Update memories by user messages and assistant responses.
@@ -49,7 +54,7 @@ class Agent extends runnable_1.Runnable {
                 logger_1.default.warn(`Memory is not defined in agent ${this.name || this.id}`);
                 return;
             }
-            return await memory.add(messages, { userId, sessionId });
+            await memory.add(messages, { userId, sessionId });
         }));
     }
     async run(input, options) {

package/lib/cjs/definitions/memory.js

@@ -12,8 +12,8 @@ function toRunnableMemories(agentName, inputs, memories) {
             throw new Error(`LLMAgent ${agentName} -> Memory ${name} -> Query variable ${query.fromVariable.toString()} not found`);
         return {
             id: name || (0, nanoid_1.nanoid)(),
-            name: name,
-            memory: memory,
+            name,
+            memory,
             query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
             options,
         };

package/lib/cjs/llm-agent.js

@@ -104,7 +104,7 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
                 type: 'json_schema',
                 jsonSchema: {
                     name: 'output',
-                    schema: schema,
+                    schema,
                     strict: true,
                 },
             },

package/lib/cjs/pipeline-agent.js

@@ -21,14 +21,15 @@ 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 = PipelineAgent_1 = class PipelineAgent extends agent_1.Agent {
     definition;
     static create(options) {
         const definition = createPipelineAgentDefinition(options);
@@ -38,7 +39,7 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Run
         super(definition, context);
         this.definition = definition;
     }
-    async run(input, options) {
+    async process(input, options) {
         // TODO: validate the input against the definition
         const { definition, context } = this;
         if (!context)
@@ -51,12 +52,15 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Run
             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 = {};
@@ -144,15 +148,17 @@ exports.PipelineAgent = PipelineAgent = PipelineAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
 function createPipelineAgentDefinition(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 +169,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,
                     {
@@ -184,10 +190,11 @@ function createPipelineAgentDefinition(options) {
         return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
     }));
     return {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        id: agentId,
         name: options.name,
         type: 'pipeline_agent',
         inputs,
+        memories,
         outputs,
         processes,
     };