@aigne/core 0.4.194 → 0.4.196

package/lib/cjs/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamTextOutputName = exports.TYPES = void 0;
+exports.TYPES = {
+    context: Symbol.for('AIGNE_CONTEXT'),
+    definition: Symbol.for('AIGNE_DEFINITION'),
+    llmModel: Symbol.for('AIGNE_LLM_MODEL'),
+    llmModelConfiguration: Symbol.for('AIGNE_LLM_MODEL_CONFIGURATION'),
+    functionRunner: Symbol.for('AIGNE_FUNCTION_RUNNER'),
+};
+exports.StreamTextOutputName = '$text';

package/lib/cjs/function-agent.js

@@ -0,0 +1,81 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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;
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const constants_1 = require("./constants");
+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 {
+    definition;
+    runner;
+    static create(options) {
+        const definition = createFunctionAgentDefinition(options);
+        return new FunctionAgent_1(definition);
+    }
+    constructor(definition, runner) {
+        super(definition);
+        this.definition = definition;
+        this.runner = runner;
+    }
+    async run(input, options) {
+        const { definition: { language, code, ...definition }, runner, } = 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({
+            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;
+    }
+};
+exports.FunctionAgent = FunctionAgent;
+exports.FunctionAgent = FunctionAgent = FunctionAgent_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.functionRunner)),
+    __metadata("design:paramtypes", [Object, function_runner_1.FunctionRunner])
+], FunctionAgent);
+function createFunctionAgentDefinition(options) {
+    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    const outputs = utils_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    return {
+        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        name: options.name,
+        type: 'function_agent',
+        inputs,
+        outputs,
+        language: options.language,
+        code: options.code,
+    };
+}

package/lib/cjs/function-runner.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionRunner = void 0;
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class FunctionRunner extends runnable_1.Runnable {
+    constructor() {
+        super({
+            id: 'function_runner',
+            type: 'function_runner',
+            name: 'Function Runner',
+            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: 'code', name: 'code', type: 'string', required: true },
+                { id: 'arguments', name: 'arguments', type: 'object', required: false },
+            ]),
+            outputs: utils_1.OrderedRecord.fromArray([
+                {
+                    id: 'result',
+                    name: 'result',
+                    type: 'object',
+                },
+            ]),
+        });
+    }
+}
+exports.FunctionRunner = FunctionRunner;

package/lib/cjs/index.js

@@ -14,4 +14,16 @@ 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("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./data-type"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./runnable"), exports);
+__exportStar(require("./pipeline-agent"), exports);
+__exportStar(require("./llm-agent"), exports);
+__exportStar(require("./llm-model"), exports);
+__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);

package/lib/cjs/llm-agent.js

@@ -0,0 +1,166 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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 lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const constants_1 = require("./constants");
+const llm_model_1 = require("./llm-model");
+const runnable_1 = require("./runnable");
+const utils_1 = require("./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 {
+    definition;
+    model;
+    static create(options) {
+        const definition = createLLMAgentDefinition(options);
+        return new LLMAgent_1(definition);
+    }
+    constructor(definition, model) {
+        super(definition);
+        this.definition = definition;
+        this.model = model;
+    }
+    async run(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 llmInputs = {
+            messages: messages.map(({ role, content }) => ({
+                role,
+                content: (0, mustache_utils_1.renderMessage)(content, input),
+            })),
+            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;
+            })
+            : undefined;
+        if (options?.stream) {
+            return new ReadableStream({
+                start: async (controller) => {
+                    try {
+                        if (textOutput) {
+                            const textStreamOutput = await model.run(llmInputs, { stream: true });
+                            for await (const chunk of textStreamOutput) {
+                                controller.enqueue({ $text: chunk.$text });
+                            }
+                        }
+                        controller.enqueue({ delta: await jsonOutput });
+                    }
+                    catch (error) {
+                        controller.error(error);
+                    }
+                    finally {
+                        controller.close();
+                    }
+                },
+            });
+        }
+        const text = textOutput ? await model.run(llmInputs) : undefined;
+        return {
+            $text: text,
+            ...(await jsonOutput),
+        };
+    }
+};
+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])
+], LLMAgent);
+function createLLMAgentDefinition(options) {
+    const inputs = ordered_map_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    const outputs = ordered_map_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({ ...i, id: (0, nanoid_1.nanoid)() })));
+    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)(),
+        name: options.name,
+        type: 'llm_agent',
+        inputs,
+        outputs,
+        messages,
+        modelOptions: options.modelOptions,
+    };
+}
+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);
+    };
+    return outputToSchema({
+        type: 'object',
+        properties: outputs,
+    });
+}

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

@@ -0,0 +1,169 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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 lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const constants_1 = require("./constants");
+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 {
+    definition;
+    model;
+    context;
+    static create(options) {
+        const definition = createLLMDecisionAgentDefinition(options);
+        return new LLMDecisionAgent_1(definition);
+    }
+    constructor(definition, model, context) {
+        super(definition);
+        this.definition = definition;
+        this.model = model;
+        this.context = context;
+    }
+    async run(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 cases = await Promise.all(utils_1.OrderedRecord.map(definition.cases, async (t) => {
+            if (!t.runnable?.id)
+                throw new Error('Runnable is required');
+            const runnable = await context.resolve(t.runnable.id);
+            // TODO: auto generate name by llm model if needed
+            const name = t.name || runnable.name;
+            if (!name)
+                throw new Error('Case name is required');
+            return { name, description: t.description, runnable, input: t.input };
+        }));
+        const llmInputs = {
+            messages: messages.map(({ role, content }) => ({
+                role,
+                content: typeof content === 'string' ? (0, utils_1.renderMessage)(content, input) : content,
+            })),
+            modelOptions: definition.modelOptions,
+            tools: cases.map((t) => {
+                // TODO: auto generate parameters by llm model if needed
+                return {
+                    type: 'function',
+                    function: {
+                        name: t.name,
+                        description: t.description,
+                        parameters: {},
+                    },
+                };
+            }),
+            toolChoice: 'required',
+        };
+        const { toolCalls } = await model.run(llmInputs);
+        // TODO: support run multiple calls
+        const functionNameToCall = toolCalls?.[0].function?.name;
+        if (!functionNameToCall)
+            throw new Error('No any runnable called');
+        const caseToCall = cases.find((i) => i.name === functionNameToCall);
+        if (!caseToCall)
+            throw new Error('Case not found');
+        // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
+        const variables = Object.fromEntries(utils_1.OrderedRecord.map(this.definition.inputs, (i) => {
+            const value = input[i.name || i.id];
+            if ((0, lodash_1.isNil)(value))
+                return null;
+            return [i.id, value];
+        }).filter(utils_1.isNonNullable));
+        const inputForCase = Object.fromEntries(Object.entries(caseToCall.input ?? {})
+            .map(([inputId, { from, fromVariableId, fromVariablePropPath }]) => {
+            const targetInput = utils_1.OrderedRecord.find(caseToCall.runnable.definition.inputs, (i) => i.id === inputId);
+            if (!targetInput?.name)
+                return null;
+            if (from !== 'variable' || !fromVariableId)
+                return null;
+            const v = variables[fromVariableId];
+            const value = fromVariablePropPath?.length ? (0, lodash_1.get)(v, fromVariablePropPath) : v;
+            return [targetInput.name, value];
+        })
+            .filter(utils_1.isNonNullable));
+        // TODO: check result structure and omit undefined values
+        return (await caseToCall.runnable.run(inputForCase, options));
+    }
+};
+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])
+], LLMDecisionAgent);
+function createLLMDecisionAgentDefinition(options) {
+    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    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) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: c.name || c.runnable.name,
+        description: c.description,
+        runnable: { id: c.runnable.id },
+        // TODO: pass input from decision to case runnable
+        input: Object.fromEntries(utils_1.OrderedRecord.map(c.runnable.definition.inputs, (inputOfCase) => {
+            const i = c.input?.[inputOfCase.name || inputOfCase.id];
+            if (!i) {
+                if (inputOfCase.required) {
+                    throw new Error(`Input ${inputOfCase.name || inputOfCase.id} for case ${c.runnable.name || c.runnable.id} is required`);
+                }
+                // ignore optional input
+                return null;
+            }
+            const inputFromDecision = utils_1.OrderedRecord.find(inputs, (input) => input.name === i.fromVariable);
+            if (!inputFromDecision)
+                throw new Error(`Input ${i.fromVariable} not found`);
+            return [
+                inputOfCase.id,
+                {
+                    from: 'variable',
+                    fromVariableId: inputFromDecision.id,
+                    fromVariablePropPath: i.fromVariablePropPath,
+                },
+            ];
+        }).filter(utils_1.isNonNullable)),
+    })));
+    return {
+        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        name: options.name,
+        type: 'llm_decision_agent',
+        inputs,
+        // TODO: decision agent outputs should be the union of all case outputs
+        outputs: utils_1.OrderedRecord.fromArray([]),
+        messages,
+        modelOptions: options.modelOptions,
+        cases,
+    };
+}

package/lib/cjs/llm-model.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMModel = void 0;
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class LLMModel extends runnable_1.Runnable {
+    constructor() {
+        super({
+            id: 'llm_model',
+            type: 'llm_model',
+            name: 'LLM Model',
+            description: 'Run a LLM model',
+            inputs: utils_1.OrderedRecord.fromArray([
+                { id: 'messages', name: 'messages', type: 'array', required: true },
+                { id: 'responseFormat', name: 'responseFormat', type: 'object' },
+                { id: 'tools', name: 'tools', type: 'array' },
+                { id: 'toolChoice', name: 'toolChoice', type: 'object' },
+                { id: 'modelOptions', name: 'modelOptions', type: 'object' },
+            ]),
+            outputs: utils_1.OrderedRecord.fromArray([
+                { id: '$text', name: '$text', type: 'string' },
+                { id: 'toolCalls', name: 'toolCalls', type: 'object' },
+            ]),
+        });
+    }
+}
+exports.LLMModel = LLMModel;

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

@@ -0,0 +1,80 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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 constants_1 = require("./constants");
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends runnable_1.Runnable {
+    definition;
+    context;
+    static create(options) {
+        const definition = createLocalFunctionAgentDefinition(options);
+        return new LocalFunctionAgent_1(definition);
+    }
+    constructor(definition, context) {
+        super(definition);
+        this.definition = definition;
+        this.context = context;
+    }
+    async run(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 }));
+        // 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;
+    }
+};
+exports.LocalFunctionAgent = LocalFunctionAgent;
+exports.LocalFunctionAgent = LocalFunctionAgent = LocalFunctionAgent_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.context)),
+    __metadata("design:paramtypes", [Object, Object])
+], LocalFunctionAgent);
+function createLocalFunctionAgentDefinition(options) {
+    const inputs = utils_1.OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    const outputs = utils_1.OrderedRecord.fromArray(options.outputs?.map((i) => ({
+        id: (0, nanoid_1.nanoid)(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    return {
+        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        name: options.name,
+        type: 'local_function_agent',
+        inputs,
+        outputs,
+        function: options.function,
+    };
+}

package/lib/cjs/memory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRunner = exports.Memory = void 0;
+const lodash_1 = require("lodash");
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+class Memory extends runnable_1.Runnable {
+    constructor() {
+        super({
+            id: 'memory',
+            type: 'memory',
+            name: 'Memory',
+            inputs: utils_1.OrderedRecord.fromArray([]),
+            outputs: utils_1.OrderedRecord.fromArray([]),
+        });
+    }
+}
+exports.Memory = Memory;
+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;