@aigne/core 0.4.205-0 → 0.4.205-1

package/lib/cjs/utils/message-utils.js

@@ -1,6 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeHistoryMessages = mergeHistoryMessages;
+exports.memoriesToMessages = memoriesToMessages;
+exports.prepareMessages = prepareMessages;
+const omit_1 = __importDefault(require("lodash/omit"));
+const is_non_nullable_1 = require("./is-non-nullable");
+const mustache_utils_1 = require("./mustache-utils");
+const ordered_map_1 = require("./ordered-map");
 function mergeHistoryMessages(messages, history) {
     const firstUserMessageIndex = messages.findIndex((m) => m.role === 'user');
     if (firstUserMessageIndex >= 0) {
@@ -8,3 +17,56 @@ function mergeHistoryMessages(messages, history) {
     }
     return [...history, ...messages];
 }
+function memoriesToMessages(memories, { primaryMemoryName } = {}) {
+    const primary = (primaryMemoryName && memories[primaryMemoryName]) || [];
+    const otherMemories = primaryMemoryName ? (0, omit_1.default)(memories, primaryMemoryName) : memories;
+    const primaryMemory = primary
+        .map((i) => {
+        const content = (0, mustache_utils_1.renderMessage)('{{memory}}', { memory: i.memory }).trim();
+        const role = ['user', 'assistant'].includes(i.metadata.role) ? i.metadata.role : undefined;
+        if (!role || !content)
+            return null;
+        return { role, content };
+    })
+        .filter(is_non_nullable_1.isNonNullable);
+    const memory = Object.values(otherMemories)
+        .map((i) => i
+        .map((j) => (0, mustache_utils_1.renderMessage)('{{memory}}\n{{metadata}}', j).trim() || null)
+        .filter(is_non_nullable_1.isNonNullable)
+        .join('\n'))
+        .join('\n');
+    return {
+        primaryMemory,
+        memory,
+    };
+}
+function prepareMessages(definition, input, memories) {
+    const variables = { ...input, ...memories };
+    const originalMessages = ordered_map_1.OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
+        role,
+        content: typeof content === 'string' ? (0, mustache_utils_1.renderMessage)(content, variables) : content,
+    }));
+    if (!originalMessages.length)
+        throw new Error('Messages are required');
+    const { primaryMemory, memory } = memoriesToMessages(memories, {
+        primaryMemoryName: ordered_map_1.OrderedRecord.find(definition.memories, (i) => i.id === definition.primaryMemoryId)?.name,
+    });
+    let messagesWithMemory = [...originalMessages];
+    // Add memory to a system message
+    if (memory) {
+        const message = {
+            role: 'system',
+            content: `\
+        Here are the memories about the user:
+        ${memory}
+        `,
+        };
+        const lastSystemMessageIndex = messagesWithMemory.findLastIndex((i) => i.role === 'assistant');
+        messagesWithMemory.splice(lastSystemMessageIndex + 1, 0, message);
+    }
+    // Add primary memory to messages
+    if (primaryMemory.length)
+        messagesWithMemory = mergeHistoryMessages(messagesWithMemory, primaryMemory);
+    // TODO: support comment/image for messages
+    return { originalMessages, messagesWithMemory };
+}

package/lib/cjs/utils/nullable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/utils/ordered-map.js

@@ -78,6 +78,18 @@ var OrderedRecord;
         return record;
     }
     OrderedRecord.push = push;
+    function merge(...records) {
+        const result = { $indexes: [] };
+        for (const record of records) {
+            for (const id of record.$indexes) {
+                if (!result[id])
+                    result.$indexes.push(id);
+                result[id] = record[id];
+            }
+        }
+        return result;
+    }
+    OrderedRecord.merge = merge;
     function pushOrUpdate(record, ...items) {
         for (const item of items) {
             if (!record[item.id]) {

package/lib/cjs/utils/stream-utils.js

@@ -2,24 +2,62 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectToRunnableResponseStream = objectToRunnableResponseStream;
 exports.runnableResponseStreamToObject = runnableResponseStreamToObject;
+exports.extractOutputsFromRunnableOutput = extractOutputsFromRunnableOutput;
 const runnable_1 = require("../runnable");
 function objectToRunnableResponseStream(obj) {
     return new ReadableStream({
         start(controller) {
-            controller.enqueue({ delta: obj });
+            controller.enqueue({ $text: obj['$text'] || undefined, delta: obj });
             controller.close();
         },
     });
 }
 async function runnableResponseStreamToObject(stream) {
     let $text = '';
-    const lastValue = {};
+    const result = {};
     for await (const value of stream) {
         if ((0, runnable_1.isRunnableResponseDelta)(value)) {
             $text += value.$text || '';
-            Object.assign(lastValue, value.delta);
+            Object.assign(result, value.delta);
         }
     }
-    Object.assign(lastValue, { $text: lastValue.$text || $text || undefined });
-    return lastValue;
+    Object.assign(result, { $text: result.$text || $text || undefined });
+    return result;
+}
+/**
+ * Extracts the outputs from a runnable output stream and run the
+ * resolve function on the result before the stream closes. It can be
+ * used to update the memories of an agent.
+ * @param output The runnable output stream or object
+ * @param resolve The function to run on the result
+ * @returns The runnable output stream or object
+ */
+async function extractOutputsFromRunnableOutput(output, resolve) {
+    if (!(output instanceof ReadableStream)) {
+        await resolve(output);
+        return output;
+    }
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                let result = {};
+                let $text = '';
+                for await (const value of output) {
+                    if ((0, runnable_1.isRunnableResponseDelta)(value)) {
+                        $text += value.$text || '';
+                        Object.assign(result, value.delta);
+                    }
+                }
+                Object.assign(result, { $text: result.$text || $text || undefined });
+                controller.enqueue({ $text: result.$text, delta: result });
+                await resolve(result);
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
 }

package/lib/esm/agent.js

@@ -0,0 +1,53 @@
+import logger from './logger';
+import { Runnable } from './runnable';
+import { OrderedRecord, isNonNullable, renderMessage } from './utils';
+export class Agent extends Runnable {
+    async getMemoryQuery(input, query) {
+        if (query?.from === 'variable') {
+            const i = 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 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(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(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(OrderedRecord.map(memories, async ({ memory }) => {
+            if (!memory) {
+                logger.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 });
+    }
+}

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

@@ -0,0 +1,43 @@
+import { nanoid } from 'nanoid';
+import { OrderedRecord } from '../utils';
+export function schemaToDataType(dataType) {
+    return OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
+        const base = {
+            ...schema,
+            id: 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: OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                };
+            default: {
+                throw new Error(`Unknown data type: ${schema.type}`);
+            }
+        }
+    }));
+}

package/lib/esm/definitions/memory.js

@@ -0,0 +1,18 @@
+import { nanoid } from 'nanoid';
+import { OrderedRecord } from '../utils';
+export function toRunnableMemories(agentName, inputs, memories) {
+    return OrderedRecord.fromArray(Object.entries(memories).map(([name, { memory, query, options }]) => {
+        const queryFromVariable = query?.fromVariable
+            ? 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 || nanoid(),
+            name: name,
+            memory: memory,
+            query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
+            options,
+        };
+    }));
+}

package/lib/esm/function-agent.js

@@ -14,7 +14,7 @@ var FunctionAgent_1;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { TYPES } from './constants';
-import { schemaToDataType } from './data-type-schema';
+import { schemaToDataType } from './definitions/data-type-schema';
 import { FunctionRunner } from './function-runner';
 import { Runnable } from './runnable';
 import { objectToRunnableResponseStream } from './utils';

package/lib/esm/function-runner.js

@@ -1,7 +1,7 @@
 import { Runnable } from './runnable';
 import { OrderedRecord } from './utils';
 export class FunctionRunner extends Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: 'function_runner',
             type: 'function_runner',
@@ -20,6 +20,6 @@ export class FunctionRunner extends Runnable {
                     type: 'object',
                 },
             ]),
-        });
+        }, context);
     }
 }

package/lib/esm/index.js

@@ -1,7 +1,7 @@
 export * from './utils';
 export * from './constants';
 export * from './data-type';
-export * from './data-type-schema';
+export * from './definitions/data-type-schema';
 export * from './context';
 export * from './runnable';
 export * from './pipeline-agent';

package/lib/esm/llm-agent.js

@@ -11,38 +11,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 var LLMAgent_1;
-import remove from 'lodash/remove';
 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 { LLMModel } from './llm-model';
-import logger from './logger';
-import { Runnable, } from './runnable';
-import { isNonNullable, runnableResponseStreamToObject } from './utils';
-import { mergeHistoryMessages } from './utils/message-utils';
+import { runnableResponseStreamToObject } from './utils';
+import { prepareMessages } from './utils/message-utils';
 import { renderMessage } from './utils/mustache-utils';
 import { OrderedRecord } from './utils/ordered-map';
 import { outputsToJsonSchema } from './utils/structured-output-schema';
-let LLMAgent = LLMAgent_1 = class LLMAgent extends Runnable {
+let LLMAgent = LLMAgent_1 = class LLMAgent extends Agent {
     definition;
     model;
-    context;
     static create(options) {
         const definition = createLLMAgentDefinition(options);
         return new LLMAgent_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, model } = this;
         if (!model)
             throw new Error('LLM model is required');
-        const { originalMessages, messagesWithMemory } = await this.prepareMessages(input);
+        const { originalMessages, messagesWithMemory } = prepareMessages(definition, input, options.memories);
         const llmInputs = {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
@@ -88,35 +85,6 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends Runnable {
         await updateMemories($text, json);
         return { $text, ...json };
     }
-    async prepareMessages(input) {
-        const { definition } = this;
-        const originalMessages = OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
-            role,
-            // TODO: support use memory variables in message content
-            content: typeof content === 'string' ? renderMessage(content, input) : content,
-        }));
-        if (!originalMessages.length)
-            throw new Error('Messages are required');
-        const { primaryMemory, memory } = await this.getMemories(input);
-        let messagesWithMemory = [...originalMessages];
-        // Add memory to a system message
-        if (memory) {
-            const message = {
-                role: 'system',
-                content: `\
-        Here are the memories about the user:
-        ${memory}
-        `,
-            };
-            const lastSystemMessageIndex = messagesWithMemory.findLastIndex((i) => i.role === 'assistant');
-            messagesWithMemory.splice(lastSystemMessageIndex + 1, 0, message);
-        }
-        // Add primary memory to messages
-        if (primaryMemory.length)
-            messagesWithMemory = mergeHistoryMessages(messagesWithMemory, primaryMemory);
-        // TODO: support comment/image for messages
-        return { originalMessages, messagesWithMemory };
-    }
     async runWithStructuredOutput(llmInputs) {
         const jsonOutputs = OrderedRecord.filter(this.definition.outputs, (i) => i.name !== StreamTextOutputName // ignore `$text` output
         );
@@ -149,73 +117,13 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends Runnable {
             throw new Error('LLM model is required');
         return model.run(llmInputs, { stream: true });
     }
-    async getMemoryQuery(input, query) {
-        if (query?.from === 'variable') {
-            const i = 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 renderMessage('{{value}}', { value });
-        }
-        return Object.entries(input)
-            .map(([key, value]) => `${key} ${value}`)
-            .join('\n');
-    }
-    async getMemories(input) {
-        const { memories } = this.definition;
-        const { userId, sessionId } = this.context?.state ?? {};
-        const list = (await Promise.all(OrderedRecord.map(memories, async ({ id, memory, query, options }) => {
-            if (!memory) {
-                logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
-                return null;
-            }
-            const q = await this.getMemoryQuery(input, query);
-            const { results: memories } = await memory.search(q, { ...options, userId, sessionId });
-            return { id, memories };
-        }))).filter(isNonNullable);
-        const primary = remove(list, (i) => i.id === this.definition.primaryMemoryId)[0]?.memories || [];
-        const primaryMemory = primary
-            .map((i) => {
-            const content = renderMessage('{{memory}}', { memory: i.memory }).trim();
-            const role = ['user', 'assistant'].includes(i.metadata.role) ? i.metadata.role : undefined;
-            if (!role || !content)
-                return null;
-            return { role, content };
-        })
-            .filter(isNonNullable);
-        const memory = list
-            .map((i) => i.memories
-            .map((j) => renderMessage('{{memory}}\n{{metadata}}', j).trim() || null)
-            .filter(isNonNullable)
-            .join('\n'))
-            .join('\n');
-        return {
-            primaryMemory,
-            memory,
-        };
-    }
-    /**
-     * 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(OrderedRecord.map(memories, async ({ memory }) => {
-            if (!memory) {
-                logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
-                return;
-            }
-            return await memory.add(messages, { userId, sessionId });
-        }));
-    }
 };
 LLMAgent = LLMAgent_1 = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.llmModel)),
-    __param(2, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, LLMModel, Object])
+    __param(1, inject(TYPES.context)),
+    __param(2, inject(TYPES.llmModel)),
+    __metadata("design:paramtypes", [Object, Object, LLMModel])
 ], LLMAgent);
 export { LLMAgent };
 /**
@@ -225,27 +133,15 @@ export { LLMAgent };
  */
 export function createLLMAgentDefinition(options) {
     const agentId = options.name || nanoid();
-    const primaryMemories = options.memories?.filter((i) => i.primary);
-    if (primaryMemories && primaryMemories.length > 1) {
-        throw new Error('Only one primary memory is allowed');
-    }
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
-    const memories = OrderedRecord.fromArray(options.memories?.map((i) => {
-        const { name, memory, query, options } = i;
-        const queryFromVariable = query?.fromVariable
-            ? OrderedRecord.find(inputs, (j) => j.name === query.fromVariable)
-            : null;
-        if (query?.fromVariable && !queryFromVariable)
-            throw new Error(`LLMAgent ${agentId} -> Memory ${name} -> Query variable ${query.fromVariable.toString()} not found`);
-        return {
-            id: name || nanoid(),
-            name: name,
-            memory: memory,
-            query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
-            options,
-        };
-    }));
+    const memories = 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 = OrderedRecord.fromArray(options.messages?.map((i) => ({
         id: nanoid(),
         role: i.role,
@@ -257,7 +153,7 @@ export function createLLMAgentDefinition(options) {
         type: 'llm_agent',
         inputs,
         outputs,
-        primaryMemoryId: primaryMemories?.at(0)?.name,
+        primaryMemoryId: primaryMemoryNames?.at(0),
         memories,
         modelOptions: options.modelOptions,
         messages,

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

@@ -13,33 +13,31 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var LLMDecisionAgent_1;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
+import { Agent } from './agent';
 import { TYPES } from './constants';
+import { toRunnableMemories } from './definitions/memory';
 import { LLMModel } from './llm-model';
-import { Runnable } from './runnable';
-import { OrderedRecord, renderMessage } from './utils';
-let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends Runnable {
+import { OrderedRecord, extractOutputsFromRunnableOutput, renderMessage } from './utils';
+import { prepareMessages } from './utils/message-utils';
+let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends 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 = OrderedRecord.toArray(definition.messages);
-        if (!messages.length)
-            throw new Error('Messages are required');
+        const { originalMessages, messagesWithMemory } = prepareMessages(definition, input, options.memories);
         const cases = await Promise.all(OrderedRecord.map(definition.cases, async (t) => {
             if (!t.runnable?.id)
                 throw new Error('Runnable is required');
@@ -48,13 +46,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' ? renderMessage(content, input) : content,
-            })),
+            messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
             tools: cases.map((t) => {
                 // TODO: auto generate parameters by llm model if needed
@@ -78,40 +73,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 extractOutputsFromRunnableOutput(output, ({ $text, ...json }) => this.updateMemories([
+            ...originalMessages,
+            { role: 'assistant', content: renderMessage('{{$text}}\n{{json}}', { $text, json }).trim() },
+        ]));
     }
 };
 LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.llmModel)),
-    __param(2, inject(TYPES.context)),
-    __metadata("design:paramtypes", [Object, LLMModel, Object])
+    __param(1, inject(TYPES.context)),
+    __param(2, inject(TYPES.llmModel)),
+    __metadata("design:paramtypes", [Object, Object, LLMModel])
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
 export function createLLMDecisionAgentDefinition(options) {
-    const messages = OrderedRecord.fromArray([
-        {
-            id: nanoid(),
-            role: 'system',
-            content: options.messages,
-        },
-    ]);
-    const cases = OrderedRecord.fromArray(options.cases.map((c) => ({
+    const agentId = options.name || nanoid();
+    const cases = OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => ({
         id: nanoid(),
-        name: c.name || c.runnable.name,
+        name: name || c.runnable.name,
         description: c.description,
         runnable: { id: c.runnable.id },
     })));
+    const inputs = OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.inputs));
+    const outputs = OrderedRecord.fromArray(OrderedRecord.map(OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.outputs)), (o) => ({ ...o, required: false })));
+    const memories = 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 = OrderedRecord.fromArray(options.messages?.map((i) => ({
+        id: nanoid(),
+        role: i.role,
+        content: i.content,
+    })));
     return {
-        id: options.id || options.name || nanoid(),
+        id: agentId,
         name: options.name,
         type: 'llm_decision_agent',
-        // TODO: decision agent inputs should be the intersection of all case inputs
-        inputs: OrderedRecord.fromArray([]),
-        // TODO: decision agent outputs should be the union of all case outputs
-        outputs: OrderedRecord.fromArray([]),
+        inputs,
+        outputs,
         messages,
+        primaryMemoryId: primaryMemoryNames?.at(0),
+        memories,
         modelOptions: options.modelOptions,
         cases,
     };

package/lib/esm/llm-model.js

@@ -1,7 +1,7 @@
 import { Runnable } from './runnable';
 import { OrderedRecord } from './utils';
 export class LLMModel extends Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: 'llm_model',
             type: 'llm_model',
@@ -18,6 +18,6 @@ export class LLMModel extends Runnable {
                 { id: '$text', name: '$text', type: 'string' },
                 { id: 'toolCalls', name: 'toolCalls', type: 'object' },
             ]),
-        });
+        }, context);
     }
 }