@aigne/core 0.4.204 → 0.4.205-1

package/lib/cjs/agent.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const logger_1 = __importDefault(require("./logger"));
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class Agent extends runnable_1.Runnable {
+    async getMemoryQuery(input, query) {
+        if (query?.from === 'variable') {
+            const i = utils_1.OrderedRecord.find(this.definition.inputs, (i) => i.id === query.fromVariableId);
+            if (!i)
+                throw new Error(`Input variable ${query.fromVariableId} not found`);
+            const value = input[i.name];
+            return (0, utils_1.renderMessage)('{{value}}', { value });
+        }
+        return Object.entries(input)
+            .map(([key, value]) => `${key} ${value}`)
+            .join('\n');
+    }
+    /**
+     * 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.
+     */
+    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 }) => {
+            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));
+    }
+    /**
+     * Update memories by user messages and assistant responses.
+     * @param messages Messages to be added to memories.
+     */
+    async updateMemories(messages) {
+        const { memories } = this.definition;
+        const { userId, sessionId } = this.context?.state ?? {};
+        await Promise.all(utils_1.OrderedRecord.map(memories, async ({ memory }) => {
+            if (!memory) {
+                logger_1.default.warn(`Memory is not defined in agent ${this.name || this.id}`);
+                return;
+            }
+            return await memory.add(messages, { userId, sessionId });
+        }));
+    }
+    async run(input, options) {
+        const memories = await this.loadMemories(input, this.context);
+        return this.process(input, { ...options, memories });
+    }
+}
+exports.Agent = Agent;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaToDataType = schemaToDataType;
+const nanoid_1 = require("nanoid");
+const utils_1 = require("../utils");
+function schemaToDataType(dataType) {
+    return utils_1.OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
+        const base = {
+            ...schema,
+            id: (0, nanoid_1.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: 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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRunnableMemories = toRunnableMemories;
+const nanoid_1 = require("nanoid");
+const utils_1 = require("../utils");
+function toRunnableMemories(agentName, inputs, memories) {
+    return utils_1.OrderedRecord.fromArray(Object.entries(memories).map(([name, { memory, query, options }]) => {
+        const queryFromVariable = query?.fromVariable
+            ? utils_1.OrderedRecord.find(inputs, (j) => j.name === query.fromVariable)
+            : null;
+        if (query?.fromVariable && !queryFromVariable)
+            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,
+            query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
+            options,
+        };
+    }));
+}

package/lib/cjs/function-agent.js

@@ -18,7 +18,7 @@ exports.createFunctionAgentDefinition = createFunctionAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const constants_1 = require("./constants");
-const data_type_schema_1 = require("./data-type-schema");
+const data_type_schema_1 = require("./definitions/data-type-schema");
 const function_runner_1 = require("./function-runner");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");

package/lib/cjs/function-runner.js

@@ -4,7 +4,7 @@ exports.FunctionRunner = void 0;
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
 class FunctionRunner extends runnable_1.Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: 'function_runner',
             type: 'function_runner',
@@ -23,7 +23,7 @@ class FunctionRunner extends runnable_1.Runnable {
                     type: 'object',
                 },
             ]),
-        });
+        }, context);
     }
 }
 exports.FunctionRunner = FunctionRunner;

package/lib/cjs/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./data-type"), exports);
-__exportStar(require("./data-type-schema"), exports);
+__exportStar(require("./definitions/data-type-schema"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./runnable"), exports);
 __exportStar(require("./pipeline-agent"), exports);
@@ -27,4 +27,4 @@ __exportStar(require("./function-agent"), exports);
 __exportStar(require("./function-runner"), exports);
 __exportStar(require("./llm-decision-agent"), exports);
 __exportStar(require("./local-function-agent"), exports);
-__exportStar(require("./memory"), exports);
+__exportStar(require("./memorable"), exports);

package/lib/cjs/llm-agent.js

@@ -15,79 +15,63 @@ var LLMAgent_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMAgent = void 0;
 exports.createLLMAgentDefinition = createLLMAgentDefinition;
-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("./data-type-schema");
+const data_type_schema_1 = require("./definitions/data-type-schema");
+const memory_1 = require("./definitions/memory");
 const llm_model_1 = require("./llm-model");
-const runnable_1 = require("./runnable");
 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");
-let LLMAgent = LLMAgent_1 = class LLMAgent extends runnable_1.Runnable {
+const structured_output_schema_1 = require("./utils/structured-output-schema");
+let LLMAgent = LLMAgent_1 = class LLMAgent extends agent_1.Agent {
     definition;
     model;
     static create(options) {
         const definition = createLLMAgentDefinition(options);
         return new LLMAgent_1(definition);
     }
-    constructor(definition, model) {
-        super(definition);
+    constructor(definition, context, model) {
+        super(definition, context);
         this.definition = definition;
         this.model = model;
     }
-    async run(input, options) {
+    async process(input, options) {
         const { definition, model } = this;
         if (!model)
             throw new Error('LLM model is required');
-        const messages = ordered_map_1.OrderedRecord.toArray(definition.messages);
-        if (!messages.length)
-            throw new Error('Messages are required');
-        // TODO: support comment/image for messages
+        const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
         const llmInputs = {
-            messages: messages.map(({ role, content }) => ({
-                role,
-                content: (0, mustache_utils_1.renderMessage)(content, input),
-            })),
+            messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
         };
-        const outputs = ordered_map_1.OrderedRecord.toArray(definition.outputs).filter((0, utils_1.isPropsNonNullable)('name'));
-        const textOutput = outputs.find((i) => i.name === constants_1.StreamTextOutputName);
-        const jsonOutputs = outputs.filter((i) => i.name !== constants_1.StreamTextOutputName);
-        const outputJsonSchema = jsonOutputs.length ? outputsToJsonSchema(ordered_map_1.OrderedRecord.fromArray(jsonOutputs)) : undefined;
-        const jsonOutput = outputJsonSchema
-            ? model
-                .run({
-                ...llmInputs,
-                responseFormat: outputJsonSchema && {
-                    type: 'json_schema',
-                    jsonSchema: {
-                        name: 'output',
-                        schema: outputJsonSchema,
-                        strict: true,
-                    },
-                },
-            })
-                .then(async (response) => {
-                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;
-            })
+        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) {
-                            const textStreamOutput = await model.run(llmInputs, { stream: true });
-                            for await (const chunk of textStreamOutput) {
+                            for await (const chunk of textOutput) {
+                                $text += chunk.$text || '';
                                 controller.enqueue({ $text: chunk.$text });
                             }
                         }
-                        controller.enqueue({ delta: await jsonOutput });
+                        const json = await jsonOutput;
+                        controller.enqueue({ delta: json });
+                        await updateMemories($text || undefined, json);
                     }
                     catch (error) {
                         controller.error(error);
@@ -98,62 +82,84 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends runnable_1.Runnable {
                 },
             });
         }
-        const text = textOutput ? await model.run(llmInputs) : undefined;
-        return {
-            $text: text?.$text,
-            ...(await jsonOutput),
-        };
+        const [$text, json] = await Promise.all([
+            textOutput ? (0, utils_1.runnableResponseStreamToObject)(textOutput).then((res) => res.$text || undefined) : undefined,
+            jsonOutput,
+        ]);
+        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
+        );
+        if (!jsonOutputs.length)
+            return null;
+        const schema = (0, structured_output_schema_1.outputsToJsonSchema)(ordered_map_1.OrderedRecord.fromArray(jsonOutputs));
+        const { model } = this;
+        if (!model)
+            throw new Error('LLM model is required');
+        const response = await model.run({
+            ...llmInputs,
+            responseFormat: {
+                type: 'json_schema',
+                jsonSchema: {
+                    name: 'output',
+                    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;
+    }
+    async runWithTextOutput(llmInputs) {
+        const { model } = this;
+        if (!model)
+            throw new Error('LLM model is required');
+        return model.run(llmInputs, { stream: true });
     }
 };
 exports.LLMAgent = LLMAgent;
 exports.LLMAgent = LLMAgent = LLMAgent_1 = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
-    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, llm_model_1.LLMModel])
+    __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])
 ], LLMAgent);
+/**
+ * Create LLMAgent definition.
+ * @param options Options to create LLMAgent.
+ * @returns LLMAgent definition.
+ */
 function createLLMAgentDefinition(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 ?? {});
+    const primaryMemoryNames = Object.entries(options.memories ?? {})
+        .filter(([, i]) => i.primary)
+        .map(([name]) => name);
+    if (primaryMemoryNames && primaryMemoryNames.length > 1) {
+        throw new Error('Only one primary memory is allowed');
+    }
+    const messages = ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        role: i.role,
+        content: i.content,
+    })));
     return {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        id: agentId,
         name: options.name,
         type: 'llm_agent',
-        inputs: (0, data_type_schema_1.schemaToDataType)(options.inputs),
-        outputs: (0, data_type_schema_1.schemaToDataType)(options.outputs),
+        inputs,
+        outputs,
+        primaryMemoryId: primaryMemoryNames?.at(0),
+        memories,
         modelOptions: options.modelOptions,
-        messages: ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
-            id: (0, nanoid_1.nanoid)(),
-            role: i.role,
-            content: i.content,
-        }))),
-    };
-}
-function outputsToJsonSchema(outputs) {
-    const outputToSchema = (output) => {
-        const properties = output.type === 'object' && output.properties?.$indexes.length
-            ? ordered_map_1.OrderedRecord.map(output.properties, (property) => {
-                if (!property.name)
-                    return null;
-                const schema = outputToSchema(property);
-                if (!schema)
-                    return null;
-                return { schema, property };
-            }).filter(utils_1.isNonNullable)
-            : undefined;
-        return (0, lodash_1.omitBy)({
-            type: output.type,
-            description: output.description,
-            properties: properties?.length
-                ? Object.fromEntries(properties.map((p) => [p.property.name, p.schema]))
-                : undefined,
-            items: output.type === 'array' && output.items ? outputToSchema(output.items) : undefined,
-            additionalProperties: output.type === 'object' ? false : undefined,
-            required: properties?.length
-                ? properties.filter((i) => i.property.required).map((i) => i.property.name)
-                : undefined,
-        }, (v) => v === undefined);
+        messages,
     };
-    return outputToSchema({
-        type: 'object',
-        properties: outputs,
-    });
 }

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

@@ -17,33 +17,31 @@ exports.LLMDecisionAgent = void 0;
 exports.createLLMDecisionAgentDefinition = createLLMDecisionAgentDefinition;
 const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
+const agent_1 = require("./agent");
 const constants_1 = require("./constants");
+const memory_1 = require("./definitions/memory");
 const llm_model_1 = require("./llm-model");
-const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
-let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends runnable_1.Runnable {
+const message_utils_1 = require("./utils/message-utils");
+let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends agent_1.Agent {
     definition;
     model;
-    context;
     static create(options) {
         const definition = createLLMDecisionAgentDefinition(options);
         return new LLMDecisionAgent_1(definition);
     }
-    constructor(definition, model, context) {
-        super(definition);
+    constructor(definition, context, model) {
+        super(definition, context);
         this.definition = definition;
         this.model = model;
-        this.context = context;
     }
-    async run(input, options) {
+    async process(input, options) {
         const { definition, context, model } = this;
         if (!model)
             throw new Error('LLM model is required');
         if (!context)
             throw new Error('Context is required');
-        const messages = utils_1.OrderedRecord.toArray(definition.messages);
-        if (!messages.length)
-            throw new Error('Messages are required');
+        const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
         const cases = await Promise.all(utils_1.OrderedRecord.map(definition.cases, async (t) => {
             if (!t.runnable?.id)
                 throw new Error('Runnable is required');
@@ -52,13 +50,10 @@ let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends runna
             const name = t.name || runnable.name;
             if (!name)
                 throw new Error('Case name is required');
-            return { name, description: t.description, runnable, input: t.input };
+            return { name, description: t.description, runnable };
         }));
         const llmInputs = {
-            messages: messages.map(({ role, content }) => ({
-                role,
-                content: typeof content === 'string' ? (0, utils_1.renderMessage)(content, input) : content,
-            })),
+            messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
             tools: cases.map((t) => {
                 // TODO: auto generate parameters by llm model if needed
@@ -82,40 +77,52 @@ let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends runna
         if (!caseToCall)
             throw new Error('Case not found');
         // TODO: check result structure and omit undefined values
-        return (await caseToCall.runnable.run(input, options));
+        const output = (await caseToCall.runnable.run(input, options));
+        return (0, utils_1.extractOutputsFromRunnableOutput)(output, ({ $text, ...json }) => this.updateMemories([
+            ...originalMessages,
+            { role: 'assistant', content: (0, utils_1.renderMessage)('{{$text}}\n{{json}}', { $text, json }).trim() },
+        ]));
     }
 };
 exports.LLMDecisionAgent = LLMDecisionAgent;
 exports.LLMDecisionAgent = LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
     (0, tsyringe_1.injectable)(),
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
-    __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
-    __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
-    __metadata("design:paramtypes", [Object, llm_model_1.LLMModel, Object])
+    __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) {
-    const messages = utils_1.OrderedRecord.fromArray([
-        {
-            id: (0, nanoid_1.nanoid)(),
-            role: 'system',
-            content: options.messages,
-        },
-    ]);
-    const cases = utils_1.OrderedRecord.fromArray(options.cases.map((c) => ({
+    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)(),
-        name: c.name || c.runnable.name,
+        name: name || c.runnable.name,
         description: c.description,
         runnable: { id: c.runnable.id },
     })));
+    const inputs = utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.inputs));
+    const outputs = utils_1.OrderedRecord.fromArray(utils_1.OrderedRecord.map(utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.outputs)), (o) => ({ ...o, required: false })));
+    const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories ?? {});
+    const primaryMemoryNames = Object.entries(options.memories ?? {})
+        .filter(([, i]) => i.primary)
+        .map(([name]) => name);
+    if (primaryMemoryNames && primaryMemoryNames.length > 1) {
+        throw new Error('Only one primary memory is allowed');
+    }
+    const messages = utils_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        role: i.role,
+        content: i.content,
+    })));
     return {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        id: agentId,
         name: options.name,
         type: 'llm_decision_agent',
-        // TODO: decision agent inputs should be the intersection of all case inputs
-        inputs: utils_1.OrderedRecord.fromArray([]),
-        // TODO: decision agent outputs should be the union of all case outputs
-        outputs: utils_1.OrderedRecord.fromArray([]),
+        inputs,
+        outputs,
         messages,
+        primaryMemoryId: primaryMemoryNames?.at(0),
+        memories,
         modelOptions: options.modelOptions,
         cases,
     };

package/lib/cjs/llm-model.js

@@ -4,7 +4,7 @@ exports.LLMModel = void 0;
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
 class LLMModel extends runnable_1.Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: 'llm_model',
             type: 'llm_model',
@@ -21,7 +21,7 @@ class LLMModel extends runnable_1.Runnable {
                 { id: '$text', name: '$text', type: 'string' },
                 { id: 'toolCalls', name: 'toolCalls', type: 'object' },
             ]),
-        });
+        }, context);
     }
 }
 exports.LLMModel = LLMModel;

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

@@ -17,29 +17,28 @@ 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("./data-type-schema");
-const runnable_1 = require("./runnable");
+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 runnable_1.Runnable {
+let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends agent_1.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
@@ -58,14 +57,17 @@ exports.LocalFunctionAgent = LocalFunctionAgent = LocalFunctionAgent_1 = __decor
     __metadata("design:paramtypes", [Object, Object])
 ], LocalFunctionAgent);
 function createLocalFunctionAgentDefinition(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 {
-        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        id: agentId,
         name: options.name,
         type: 'local_function_agent',
         inputs,
         outputs,
+        memories,
         function: options.function,
     };
 }

package/lib/cjs/memorable.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRunner = exports.Memorable = void 0;
+const lodash_1 = require("lodash");
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class Memorable extends runnable_1.Runnable {
+    constructor() {
+        super({
+            id: 'memory',
+            type: 'memory',
+            name: 'Memory',
+            inputs: utils_1.OrderedRecord.fromArray([]),
+            outputs: utils_1.OrderedRecord.fromArray([]),
+        });
+    }
+}
+exports.Memorable = Memorable;
+class MemoryRunner extends runnable_1.Runnable {
+    constructor(name) {
+        const id = `${(0, lodash_1.camelCase)(name)}_runner`;
+        super({
+            id,
+            type: id,
+            name: `${(0, lodash_1.startCase)(name)} Runner`,
+            description: `${(0, lodash_1.startCase)(name)} Runner`,
+            inputs: utils_1.OrderedRecord.fromArray([]),
+            outputs: utils_1.OrderedRecord.fromArray([]),
+        });
+    }
+}
+exports.MemoryRunner = MemoryRunner;