@aigne/core 0.4.205-1 → 0.4.206

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,12 +54,38 @@ 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) {
         const memories = await this.loadMemories(input, this.context);
-        return this.process(input, { ...options, memories });
+        const processResult = await this.process(input, { ...options, memories });
+        if (options?.stream) {
+            const stream = processResult instanceof ReadableStream ||
+                (0, utils_1.isAsyncGenerator)(processResult)
+                ? processResult
+                : (0, utils_1.objectToRunnableResponseStream)(processResult);
+            return (0, utils_1.extractOutputsFromRunnableOutput)(stream, async (result) => {
+                // TODO: validate result against outputs schema
+                await this.onResult(result);
+            });
+        }
+        const result = processResult instanceof ReadableStream
+            ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
+            : Symbol.asyncIterator in processResult
+                ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
+                : processResult;
+        // TODO: validate result against outputs schema
+        await this.onResult(result);
+        return result;
+    }
+    /**
+     * Hook that is called before the agent result is returned.
+     * @param _result The agent result.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async onResult(_result) {
+        // Override this method to perform additional operations before the result is returned
     }
 }
 exports.Agent = Agent;

package/lib/cjs/definitions/data-type-schema.js

@@ -30,13 +30,13 @@ function schemaToDataType(dataType) {
                 return {
                     ...base,
                     type: 'object',
-                    properties: schemaToDataType(schema.properties),
+                    properties: schema.properties && schemaToDataType(schema.properties),
                 };
             case 'array':
                 return {
                     ...base,
                     type: 'array',
-                    items: utils_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                    items: schema.items && utils_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
                 };
             default: {
                 throw new Error(`Unknown data type: ${schema.type}`);

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/function-agent.js

@@ -11,60 +11,65 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var FunctionAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = void 0;
-exports.createFunctionAgentDefinition = createFunctionAgentDefinition;
+exports.create = create;
 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 function_runner_1 = require("./function-runner");
-const runnable_1 = require("./runnable");
-const utils_1 = require("./utils");
-let FunctionAgent = FunctionAgent_1 = class FunctionAgent extends runnable_1.Runnable {
+let FunctionAgent = class FunctionAgent extends agent_1.Agent {
     definition;
     runner;
-    static create(options) {
-        const definition = createFunctionAgentDefinition(options);
-        return new FunctionAgent_1(definition);
-    }
-    constructor(definition, runner) {
-        super(definition);
+    static create = create;
+    constructor(definition, context, runner) {
+        super(definition, context);
         this.definition = definition;
         this.runner = runner;
+        this.runner ??= context?.resolveDependency(constants_1.TYPES.functionRunner);
     }
-    async run(input, options) {
-        const { definition: { language, code, ...definition }, runner, } = this;
+    async process(input, options) {
+        const { definition: { language, code, ...definition }, runner, context, } = this;
         if (!runner)
             throw new Error('Function runner is required');
-        if (!language || !code)
-            throw new Error('Language and code are required');
-        const result = await runner.run({
+        if (!code)
+            throw new Error('Code is required');
+        if (!context)
+            throw new Error('Context is required');
+        return await runner.run({
             name: definition.name || definition.id,
             language,
             code,
-            arguments: input,
-        });
-        // TODO: validate the result against the definition.outputs
-        return options?.stream ? (0, utils_1.objectToRunnableResponseStream)(result) : result;
+            input,
+            memories: options.memories,
+            context: { state: context.state },
+        }, { stream: true });
     }
 };
 exports.FunctionAgent = FunctionAgent;
-exports.FunctionAgent = FunctionAgent = FunctionAgent_1 = __decorate([
+exports.FunctionAgent = FunctionAgent = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
-    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, function_runner_1.FunctionRunner])
+    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
+    __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.functionRunner)),
+    __metadata("design:paramtypes", [Object, Object, function_runner_1.FunctionRunner])
 ], FunctionAgent);
-function createFunctionAgentDefinition(options) {
-    return {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+function create({ context, ...options }) {
+    const agentId = options.name || (0, nanoid_1.nanoid)();
+    const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
+    const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
+    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories ?? {});
+    return new FunctionAgent({
+        id: agentId,
         name: options.name,
         type: 'function_agent',
-        inputs: (0, data_type_schema_1.schemaToDataType)(options.inputs),
-        outputs: (0, data_type_schema_1.schemaToDataType)(options.outputs),
+        inputs,
+        outputs,
+        memories,
         language: options.language,
         code: options.code,
-    };
+    }, context);
 }

package/lib/cjs/function-runner.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionRunner = void 0;
-const runnable_1 = require("./runnable");
+const agent_1 = require("./agent");
 const utils_1 = require("./utils");
-class FunctionRunner extends runnable_1.Runnable {
+class FunctionRunner extends agent_1.Agent {
     constructor(context) {
         super({
             id: 'function_runner',
@@ -12,9 +12,11 @@ class FunctionRunner extends runnable_1.Runnable {
             description: 'Run a function',
             inputs: utils_1.OrderedRecord.fromArray([
                 { id: 'name', name: 'name', type: 'string', required: true },
-                { id: 'language', name: 'language', type: 'string', required: true },
+                { id: 'language', name: 'language', type: 'string' },
                 { id: 'code', name: 'code', type: 'string', required: true },
-                { id: 'arguments', name: 'arguments', type: 'object', required: false },
+                { id: 'input', name: 'input', type: 'object', required: true },
+                { id: 'memories', name: 'memories', type: 'object', required: true },
+                { id: 'context', name: 'context', type: 'object', required: true },
             ]),
             outputs: utils_1.OrderedRecord.fromArray([
                 {

package/lib/cjs/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./data-type"), exports);
+__exportStar(require("./definitions/data-type"), exports);
 __exportStar(require("./definitions/data-type-schema"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./runnable"), exports);

package/lib/cjs/llm-agent.js

@@ -11,10 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var LLMAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMAgent = void 0;
-exports.createLLMAgentDefinition = createLLMAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
@@ -22,24 +20,21 @@ const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
 const llm_model_1 = require("./llm-model");
-const utils_1 = require("./utils");
 const message_utils_1 = require("./utils/message-utils");
 const mustache_utils_1 = require("./utils/mustache-utils");
 const ordered_map_1 = require("./utils/ordered-map");
 const structured_output_schema_1 = require("./utils/structured-output-schema");
-let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
+let LLMAgent = class LLMAgent extends agent_1.Agent {
     definition;
     model;
-    static create(options) {
-        const definition = createLLMAgentDefinition(options);
-        return new LLMAgent_1(definition);
-    }
+    static create = create;
     constructor(definition, context, model) {
         super(definition, context);
         this.definition = definition;
         this.model = model;
+        this.model ??= context?.resolveDependency(constants_1.TYPES.llmModel);
     }
-    async process(input, options) {
+    async *process(input, options) {
         const { definition, model } = this;
         if (!model)
             throw new Error('LLM model is required');
@@ -48,46 +43,21 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
         };
-        const jsonOutput = this.runWithStructuredOutput(llmInputs);
-        const textOutput = ordered_map_1.OrderedRecord.find(definition.outputs, (i) => i.name === constants_1.StreamTextOutputName)
-            ? await this.runWithTextOutput(llmInputs)
-            : undefined;
-        const updateMemories = (text, json) => {
-            return this.updateMemories([
-                ...originalMessages,
-                { role: 'assistant', content: (0, mustache_utils_1.renderMessage)('{{text}}\n{{json}}', { text, json }).trim() },
-            ]);
-        };
-        if (options?.stream) {
-            let $text = '';
-            return new ReadableStream({
-                start: async (controller) => {
-                    try {
-                        if (textOutput) {
-                            for await (const chunk of textOutput) {
-                                $text += chunk.$text || '';
-                                controller.enqueue({ $text: chunk.$text });
-                            }
-                        }
-                        const json = await jsonOutput;
-                        controller.enqueue({ delta: json });
-                        await updateMemories($text || undefined, json);
-                    }
-                    catch (error) {
-                        controller.error(error);
-                    }
-                    finally {
-                        controller.close();
-                    }
-                },
-            });
+        let $text = '';
+        const hasTextOutput = ordered_map_1.OrderedRecord.find(definition.outputs, (i) => i.name === constants_1.StreamTextOutputName);
+        if (hasTextOutput) {
+            for await (const chunk of await this.runWithTextOutput(llmInputs)) {
+                $text += chunk.$text || '';
+                yield { $text: chunk.$text };
+            }
         }
-        const [$text, json] = await Promise.all([
-            textOutput ? (0, utils_1.runnableResponseStreamToObject)(textOutput).then((res) => res.$text || undefined) : undefined,
-            jsonOutput,
+        const json = await this.runWithStructuredOutput(llmInputs);
+        if (json)
+            yield { delta: json };
+        await this.updateMemories([
+            ...originalMessages,
+            { role: 'assistant', content: (0, mustache_utils_1.renderMessage)('{{$text}}\n{{json}}', { $text, json }).trim() },
         ]);
-        await updateMemories($text, json);
-        return { $text, ...json };
     }
     async runWithStructuredOutput(llmInputs) {
         const jsonOutputs = ordered_map_1.OrderedRecord.filter(this.definition.outputs, (i) => i.name !== constants_1.StreamTextOutputName // ignore `$text` output
@@ -104,16 +74,14 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
                 type: 'json_schema',
                 jsonSchema: {
                     name: 'output',
-                    schema: schema,
+                    schema,
                     strict: true,
                 },
             },
         });
         if (!response.$text)
             throw new Error('No text in JSON mode response');
-        const json = JSON.parse(response.$text);
-        // TODO: validate json with outputJsonSchema
-        return json;
+        return JSON.parse(response.$text);
     }
     async runWithTextOutput(llmInputs) {
         const { model } = this;
@@ -123,7 +91,7 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
     }
 };
 exports.LLMAgent = LLMAgent;
-exports.LLMAgent = LLMAgent = LLMAgent_1 = __decorate([
+exports.LLMAgent = LLMAgent = __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)),
@@ -135,7 +103,7 @@ exports.LLMAgent = LLMAgent = LLMAgent_1 = __decorate([
  * @param options Options to create LLMAgent.
  * @returns LLMAgent definition.
  */
-function createLLMAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
     const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
@@ -151,7 +119,7 @@ function createLLMAgentDefinition(options) {
         role: i.role,
         content: i.content,
     })));
-    return {
+    return new LLMAgent({
         id: agentId,
         name: options.name,
         type: 'llm_agent',
@@ -161,5 +129,5 @@ function createLLMAgentDefinition(options) {
         memories,
         modelOptions: options.modelOptions,
         messages,
-    };
+    }, context);
 }

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

@@ -11,10 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var LLMDecisionAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMDecisionAgent = void 0;
-exports.createLLMDecisionAgentDefinition = createLLMDecisionAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
@@ -23,17 +21,15 @@ const memory_1 = require("./definitions/memory");
 const llm_model_1 = require("./llm-model");
 const utils_1 = require("./utils");
 const message_utils_1 = require("./utils/message-utils");
-let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends agent_1.Agent {
+let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
     definition;
     model;
-    static create(options) {
-        const definition = createLLMDecisionAgentDefinition(options);
-        return new LLMDecisionAgent_1(definition);
-    }
+    static create = create;
     constructor(definition, context, model) {
         super(definition, context);
         this.definition = definition;
         this.model = model;
+        this.model ??= context?.resolveDependency(constants_1.TYPES.llmModel);
     }
     async process(input, options) {
         const { definition, context, model } = this;
@@ -77,7 +73,7 @@ let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends agent
         if (!caseToCall)
             throw new Error('Case not found');
         // TODO: check result structure and omit undefined values
-        const output = (await caseToCall.runnable.run(input, options));
+        const output = await caseToCall.runnable.run(input, { stream: true });
         return (0, utils_1.extractOutputsFromRunnableOutput)(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
             { role: 'assistant', content: (0, utils_1.renderMessage)('{{$text}}\n{{json}}', { $text, json }).trim() },
@@ -85,14 +81,14 @@ let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends agent
     }
 };
 exports.LLMDecisionAgent = LLMDecisionAgent;
-exports.LLMDecisionAgent = LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
+exports.LLMDecisionAgent = LLMDecisionAgent = __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)),
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
     __metadata("design:paramtypes", [Object, Object, llm_model_1.LLMModel])
 ], LLMDecisionAgent);
-function createLLMDecisionAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const cases = utils_1.OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => ({
         id: (0, nanoid_1.nanoid)(),
@@ -114,7 +110,7 @@ function createLLMDecisionAgentDefinition(options) {
         role: i.role,
         content: i.content,
     })));
-    return {
+    return new LLMDecisionAgent({
         id: agentId,
         name: options.name,
         type: 'llm_decision_agent',
@@ -125,5 +121,5 @@ function createLLMDecisionAgentDefinition(options) {
         memories,
         modelOptions: options.modelOptions,
         cases,
-    };
+    }, context);
 }

package/lib/cjs/llm-model.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMModel = void 0;
-const runnable_1 = require("./runnable");
+const agent_1 = require("./agent");
 const utils_1 = require("./utils");
-class LLMModel extends runnable_1.Runnable {
+class LLMModel extends agent_1.Agent {
     constructor(context) {
         super({
             id: 'llm_model',

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

@@ -11,23 +11,17 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var LocalFunctionAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalFunctionAgent = void 0;
-exports.createLocalFunctionAgentDefinition = createLocalFunctionAgentDefinition;
 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 utils_1 = require("./utils");
-let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends agent_1.Agent {
+let LocalFunctionAgent = class LocalFunctionAgent extends agent_1.Agent {
     definition;
-    static create(options) {
-        const definition = createLocalFunctionAgentDefinition(options);
-        return new LocalFunctionAgent_1(definition);
-    }
+    static create = create;
     constructor(definition, context) {
         super(definition, context);
         this.definition = definition;
@@ -38,30 +32,22 @@ let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends
             throw new Error('Function is required');
         if (!context)
             throw new Error('Context is required');
-        const result = await func(input, { context, memories: options.memories });
-        // TODO: validate the result against the definition.outputs
-        return options?.stream
-            ? result instanceof ReadableStream
-                ? result
-                : (0, utils_1.objectToRunnableResponseStream)(result)
-            : result instanceof ReadableStream
-                ? (0, utils_1.runnableResponseStreamToObject)(result)
-                : result;
+        return await func(input, { context, memories: options.memories });
     }
 };
 exports.LocalFunctionAgent = LocalFunctionAgent;
-exports.LocalFunctionAgent = LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
+exports.LocalFunctionAgent = LocalFunctionAgent = __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])
 ], LocalFunctionAgent);
-function createLocalFunctionAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
     const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
     const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
-    return {
+    return new LocalFunctionAgent({
         id: agentId,
         name: options.name,
         type: 'local_function_agent',
@@ -69,5 +55,5 @@ function createLocalFunctionAgentDefinition(options) {
         outputs,
         memories,
         function: options.function,
-    };
+    }, context);
 }