@aigne/core 0.4.205 → 0.4.206

package/lib/cjs/utils/index.js

@@ -14,7 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ordered-map"), exports);
 __exportStar(require("./is-non-nullable"), exports);
-__exportStar(require("./stream-utils"), exports);
 __exportStar(require("./mustache-utils"), exports);
+__exportStar(require("./nullable"), exports);
+__exportStar(require("./omit"), exports);
+__exportStar(require("./ordered-map"), exports);
+__exportStar(require("./stream-utils"), exports);
+__exportStar(require("./union"), exports);

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectToRunnableResponseStream = objectToRunnableResponseStream;
 exports.runnableResponseStreamToObject = runnableResponseStreamToObject;
 exports.extractOutputsFromRunnableOutput = extractOutputsFromRunnableOutput;
+exports.asyncGeneratorToReadableStream = asyncGeneratorToReadableStream;
+exports.isAsyncGenerator = isAsyncGenerator;
 const runnable_1 = require("../runnable");
 function objectToRunnableResponseStream(obj) {
     return new ReadableStream({
@@ -33,24 +35,41 @@ async function runnableResponseStreamToObject(stream) {
  * @returns The runnable output stream or object
  */
 async function extractOutputsFromRunnableOutput(output, resolve) {
-    if (!(output instanceof ReadableStream)) {
-        await resolve(output);
-        return output;
+    if (output instanceof ReadableStream || isAsyncGenerator(output)) {
+        return new ReadableStream({
+            async start(controller) {
+                try {
+                    const result = {};
+                    let $text = '';
+                    for await (const value of output) {
+                        if ((0, runnable_1.isRunnableResponseDelta)(value)) {
+                            controller.enqueue(value);
+                            $text += value.$text || '';
+                            Object.assign(result, value.delta);
+                        }
+                    }
+                    Object.assign(result, { $text: result.$text || $text || undefined });
+                    await resolve(result);
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+                finally {
+                    controller.close();
+                }
+            },
+        });
     }
+    await resolve(output);
+    return output;
+}
+function asyncGeneratorToReadableStream(generator) {
     return new ReadableStream({
         async start(controller) {
             try {
-                const result = {};
-                let $text = '';
-                for await (const value of output) {
-                    if ((0, runnable_1.isRunnableResponseDelta)(value)) {
-                        $text += value.$text || '';
-                        Object.assign(result, value.delta);
-                    }
+                for await (const value of generator) {
+                    controller.enqueue(value);
                 }
-                Object.assign(result, { $text: result.$text || $text || undefined });
-                controller.enqueue({ $text: result.$text, delta: result });
-                await resolve(result);
             }
             catch (error) {
                 controller.error(error);
@@ -61,3 +80,6 @@ async function extractOutputsFromRunnableOutput(output, resolve) {
         },
     });
 }
+function isAsyncGenerator(value) {
+    return Symbol.asyncIterator in value;
+}

package/lib/esm/agent.js

@@ -1,6 +1,6 @@
 import logger from './logger';
-import { Runnable } from './runnable';
-import { OrderedRecord, isNonNullable, renderMessage } from './utils';
+import { Runnable, } from './runnable';
+import { OrderedRecord, extractOutputsFromRunnableOutput, isAsyncGenerator, isNonNullable, objectToRunnableResponseStream, renderMessage, runnableResponseStreamToObject, } from './utils';
 export class Agent extends Runnable {
     async getMemoryQuery(input, query) {
         if (query?.from === 'variable') {
@@ -53,6 +53,32 @@ export class Agent extends Runnable {
     }
     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 ||
+                isAsyncGenerator(processResult)
+                ? processResult
+                : objectToRunnableResponseStream(processResult);
+            return extractOutputsFromRunnableOutput(stream, async (result) => {
+                // TODO: validate result against outputs schema
+                await this.onResult(result);
+            });
+        }
+        const result = processResult instanceof ReadableStream
+            ? await runnableResponseStreamToObject(processResult)
+            : Symbol.asyncIterator in processResult
+                ? await 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
     }
 }

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

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

package/lib/esm/function-agent.js

@@ -10,57 +10,62 @@ 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;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
+import { Agent } from './agent';
 import { TYPES } from './constants';
 import { schemaToDataType } from './definitions/data-type-schema';
+import { toRunnableMemories } from './definitions/memory';
 import { FunctionRunner } from './function-runner';
-import { Runnable } from './runnable';
-import { objectToRunnableResponseStream } from './utils';
-let FunctionAgent = FunctionAgent_1 = class FunctionAgent extends Runnable {
+let FunctionAgent = class FunctionAgent extends 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(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 ? objectToRunnableResponseStream(result) : result;
+            input,
+            memories: options.memories,
+            context: { state: context.state },
+        }, { stream: true });
     }
 };
-FunctionAgent = FunctionAgent_1 = __decorate([
+FunctionAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, FunctionRunner])
+    __param(1, inject(TYPES.context)),
+    __param(2, inject(TYPES.functionRunner)),
+    __metadata("design:paramtypes", [Object, Object, FunctionRunner])
 ], FunctionAgent);
 export { FunctionAgent };
-export function createFunctionAgentDefinition(options) {
-    return {
-        id: options.id || options.name || nanoid(),
+export function create({ context, ...options }) {
+    const agentId = options.name || nanoid();
+    const inputs = schemaToDataType(options.inputs);
+    const outputs = schemaToDataType(options.outputs);
+    const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
+    return new FunctionAgent({
+        id: agentId,
         name: options.name,
         type: 'function_agent',
-        inputs: schemaToDataType(options.inputs),
-        outputs: schemaToDataType(options.outputs),
+        inputs,
+        outputs,
+        memories,
         language: options.language,
         code: options.code,
-    };
+    }, context);
 }

package/lib/esm/function-runner.js

@@ -1,6 +1,6 @@
-import { Runnable } from './runnable';
+import { Agent } from './agent';
 import { OrderedRecord } from './utils';
-export class FunctionRunner extends Runnable {
+export class FunctionRunner extends Agent {
     constructor(context) {
         super({
             id: 'function_runner',
@@ -9,9 +9,11 @@ export class FunctionRunner extends Runnable {
             description: 'Run a function',
             inputs: 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: OrderedRecord.fromArray([
                 {

package/lib/esm/index.js

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

package/lib/esm/llm-agent.js

@@ -10,7 +10,6 @@ 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;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { Agent } from './agent';
@@ -18,24 +17,21 @@ import { StreamTextOutputName, TYPES } from './constants';
 import { schemaToDataType } from './definitions/data-type-schema';
 import { toRunnableMemories } from './definitions/memory';
 import { LLMModel } from './llm-model';
-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 Agent {
+let LLMAgent = class LLMAgent extends 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(TYPES.llmModel);
     }
-    async process(input, options) {
+    async *process(input, options) {
         const { definition, model } = this;
         if (!model)
             throw new Error('LLM model is required');
@@ -44,46 +40,21 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends Agent {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
         };
-        const jsonOutput = this.runWithStructuredOutput(llmInputs);
-        const textOutput = OrderedRecord.find(definition.outputs, (i) => i.name === StreamTextOutputName)
-            ? await this.runWithTextOutput(llmInputs)
-            : undefined;
-        const updateMemories = (text, json) => {
-            return this.updateMemories([
-                ...originalMessages,
-                { role: 'assistant', content: 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 = OrderedRecord.find(definition.outputs, (i) => i.name === 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 ? 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: renderMessage('{{$text}}\n{{json}}', { $text, json }).trim() },
         ]);
-        await updateMemories($text, json);
-        return { $text, ...json };
     }
     async runWithStructuredOutput(llmInputs) {
         const jsonOutputs = OrderedRecord.filter(this.definition.outputs, (i) => i.name !== StreamTextOutputName // ignore `$text` output
@@ -107,9 +78,7 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends Agent {
         });
         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;
@@ -118,7 +87,7 @@ let LLMAgent = LLMAgent_1 = class LLMAgent extends Agent {
         return model.run(llmInputs, { stream: true });
     }
 };
-LLMAgent = LLMAgent_1 = __decorate([
+LLMAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
@@ -131,7 +100,7 @@ export { LLMAgent };
  * @param options Options to create LLMAgent.
  * @returns LLMAgent definition.
  */
-export function createLLMAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
@@ -147,7 +116,7 @@ export function createLLMAgentDefinition(options) {
         role: i.role,
         content: i.content,
     })));
-    return {
+    return new LLMAgent({
         id: agentId,
         name: options.name,
         type: 'llm_agent',
@@ -157,5 +126,5 @@ export function createLLMAgentDefinition(options) {
         memories,
         modelOptions: options.modelOptions,
         messages,
-    };
+    }, context);
 }

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

@@ -10,7 +10,6 @@ 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;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { Agent } from './agent';
@@ -19,17 +18,15 @@ import { toRunnableMemories } from './definitions/memory';
 import { LLMModel } from './llm-model';
 import { OrderedRecord, extractOutputsFromRunnableOutput, renderMessage } from './utils';
 import { prepareMessages } from './utils/message-utils';
-let LLMDecisionAgent = LLMDecisionAgent_1 = class LLMDecisionAgent extends Agent {
+let LLMDecisionAgent = class LLMDecisionAgent extends 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(TYPES.llmModel);
     }
     async process(input, options) {
         const { definition, context, model } = this;
@@ -73,14 +70,14 @@ 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 extractOutputsFromRunnableOutput(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
             { role: 'assistant', content: renderMessage('{{$text}}\n{{json}}', { $text, json }).trim() },
         ]));
     }
 };
-LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
+LLMDecisionAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
@@ -88,7 +85,7 @@ LLMDecisionAgent = LLMDecisionAgent_1 = __decorate([
     __metadata("design:paramtypes", [Object, Object, LLMModel])
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
-export function createLLMDecisionAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const cases = OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => ({
         id: nanoid(),
@@ -110,7 +107,7 @@ export function createLLMDecisionAgentDefinition(options) {
         role: i.role,
         content: i.content,
     })));
-    return {
+    return new LLMDecisionAgent({
         id: agentId,
         name: options.name,
         type: 'llm_decision_agent',
@@ -121,5 +118,5 @@ export function createLLMDecisionAgentDefinition(options) {
         memories,
         modelOptions: options.modelOptions,
         cases,
-    };
+    }, context);
 }

package/lib/esm/llm-model.js

@@ -1,6 +1,6 @@
-import { Runnable } from './runnable';
+import { Agent } from './agent';
 import { OrderedRecord } from './utils';
-export class LLMModel extends Runnable {
+export class LLMModel extends Agent {
     constructor(context) {
         super({
             id: 'llm_model',

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

@@ -10,20 +10,15 @@ 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;
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
 import { Agent } from './agent';
 import { TYPES } from './constants';
 import { schemaToDataType } from './definitions/data-type-schema';
 import { toRunnableMemories } from './definitions/memory';
-import { objectToRunnableResponseStream, runnableResponseStreamToObject } from './utils';
-let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends Agent {
+let LocalFunctionAgent = class LocalFunctionAgent extends 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;
@@ -34,30 +29,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
-                : objectToRunnableResponseStream(result)
-            : result instanceof ReadableStream
-                ? runnableResponseStreamToObject(result)
-                : result;
+        return await func(input, { context, memories: options.memories });
     }
 };
-LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
+LocalFunctionAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], LocalFunctionAgent);
 export { LocalFunctionAgent };
-export function createLocalFunctionAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
     const memories = toRunnableMemories(agentId, inputs, options.memories || {});
-    return {
+    return new LocalFunctionAgent({
         id: agentId,
         name: options.name,
         type: 'local_function_agent',
@@ -65,5 +52,5 @@ export function createLocalFunctionAgentDefinition(options) {
         outputs,
         memories,
         function: options.function,
-    };
+    }, context);
 }

package/lib/esm/pipeline-agent.js

@@ -10,7 +10,6 @@ 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 PipelineAgent_1;
 import { get, isNil } from 'lodash';
 import { nanoid } from 'nanoid';
 import { inject, injectable } from 'tsyringe';
@@ -19,21 +18,16 @@ import { StreamTextOutputName, TYPES } from './constants';
 import { schemaToDataType } from './definitions/data-type-schema';
 import { toRunnableMemories } from './definitions/memory';
 import logger from './logger';
-import { runnableResponseStreamToObject } from './utils';
 import { isNonNullable } from './utils/is-non-nullable';
 import { OrderedRecord } from './utils/ordered-map';
-let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Agent {
+let PipelineAgent = class PipelineAgent extends 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 process(input, options) {
-        // TODO: validate the input against the definition
         const { definition, context } = this;
         if (!context)
             throw new Error('Context is required');
@@ -41,7 +35,7 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Agent {
         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 的值
@@ -102,6 +96,8 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Agent {
                                 result = Object.fromEntries(OrderedRecord.map(definition.outputs, (output) => {
                                     if (!output.name)
                                         return null;
+                                    if (output.name === StreamTextOutputName)
+                                        return null;
                                     let value;
                                     if (output.from === 'variable') {
                                         const v = variables[output.fromVariableId];
@@ -126,21 +122,16 @@ let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends Agent {
                 }
             },
         });
-        if (options?.stream) {
-            return result;
-        }
-        // TODO: validate the result against the definition.outputs
-        return await runnableResponseStreamToObject(result);
     }
 };
-PipelineAgent = PipelineAgent_1 = __decorate([
+PipelineAgent = __decorate([
     injectable(),
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
 export { PipelineAgent };
-export function createPipelineAgentDefinition(options) {
+function create({ context, ...options }) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const memories = toRunnableMemories(agentId, inputs, options.memories || {});
@@ -182,7 +173,7 @@ export function createPipelineAgentDefinition(options) {
             throw new Error(`Output ${output.name} not found in inputs or processes`);
         return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
     }));
-    return {
+    return new PipelineAgent({
         id: agentId,
         name: options.name,
         type: 'pipeline_agent',
@@ -190,5 +181,5 @@ export function createPipelineAgentDefinition(options) {
         memories,
         outputs,
         processes,
-    };
+    }, context);
 }

package/lib/esm/runnable.js

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