@aigne/core 0.4.194 → 0.4.196

package/lib/cjs/pipeline-agent.js

@@ -0,0 +1,199 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var PipelineAgent_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineAgent = void 0;
+exports.createPipelineAgentDefinition = createPipelineAgentDefinition;
+const lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const tsyringe_1 = require("tsyringe");
+const constants_1 = require("./constants");
+const logger_1 = __importDefault(require("./logger"));
+const runnable_1 = require("./runnable");
+const utils_1 = require("./utils");
+const is_non_nullable_1 = require("./utils/is-non-nullable");
+const ordered_map_1 = require("./utils/ordered-map");
+let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends runnable_1.Runnable {
+    definition;
+    context;
+    static create(options) {
+        const definition = createPipelineAgentDefinition(options);
+        return new PipelineAgent_1(definition);
+    }
+    constructor(definition, context) {
+        super(definition);
+        this.definition = definition;
+        this.context = context;
+    }
+    async run(input, options) {
+        // TODO: validate the input against the definition
+        const { definition, context } = this;
+        if (!context)
+            throw new Error('Context is required');
+        const { processes } = definition;
+        if (!processes?.$indexes.length) {
+            throw new Error('No processes defined');
+        }
+        const result = new ReadableStream({
+            async start(controller) {
+                try {
+                    // NOTE: 将 input 转换为 variables，其中 key 为 inputId，value 为 input 的值
+                    const variables = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.inputs, (i) => {
+                        const value = input[i.name || i.id];
+                        if ((0, lodash_1.isNil)(value))
+                            return null;
+                        return [i.id, value];
+                    }).filter(is_non_nullable_1.isNonNullable));
+                    const outputs = ordered_map_1.OrderedRecord.toArray(definition.outputs);
+                    const textStreamOutput = outputs.find((i) => i.name === constants_1.StreamTextOutputName);
+                    let result = {};
+                    for (const process of ordered_map_1.OrderedRecord.iterator(processes)) {
+                        if (!process.runnable?.id) {
+                            logger_1.default.warn('Runnable id is required for process', process);
+                            continue;
+                        }
+                        const runnable = await context.resolve(process.runnable.id);
+                        if (!runnable)
+                            continue;
+                        const inputValues = Object.fromEntries(Object.entries(process.input ?? {})
+                            .map(([inputId, input]) => {
+                            const targetInput = runnable.definition.inputs?.[inputId];
+                            if (!targetInput?.name)
+                                return null;
+                            let value;
+                            if (input.from === 'variable') {
+                                const v = variables[input.fromVariableId];
+                                value = input.fromVariablePropPath?.length ? (0, lodash_1.get)(v, input.fromVariablePropPath) : v;
+                            }
+                            else {
+                                throw new Error('Unsupported input source');
+                            }
+                            return [targetInput.name, value];
+                        })
+                            .filter(is_non_nullable_1.isNonNullable));
+                        const stream = await runnable.run(inputValues, { stream: true });
+                        const needRespondTextStream = textStreamOutput?.from === 'variable' && textStreamOutput.fromVariableId === process.id;
+                        const needRespondJsonStream = outputs.some((i) => i.name !== constants_1.StreamTextOutputName && i.from === 'variable' && i.fromVariableId === process.id);
+                        for await (const chunk of stream) {
+                            if (chunk.$text && needRespondTextStream) {
+                                controller.enqueue({ $text: chunk.$text });
+                            }
+                            if (chunk.delta) {
+                                variables[process.id] = chunk.delta;
+                                if (needRespondJsonStream) {
+                                    result = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.outputs, (output) => {
+                                        if (!output.name)
+                                            return null;
+                                        let value;
+                                        if (output.from === 'variable') {
+                                            const v = variables[output.fromVariableId];
+                                            value = output.fromVariablePropPath?.length ? (0, lodash_1.get)(v, output.fromVariablePropPath) : v;
+                                        }
+                                        else {
+                                            throw new Error(`Unsupported output source ${output.from}`);
+                                        }
+                                        return [output.name, value];
+                                    }).filter(is_non_nullable_1.isNonNullable));
+                                    controller.enqueue({ delta: result });
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+                finally {
+                    controller.close();
+                }
+            },
+        });
+        if (options?.stream) {
+            return result;
+        }
+        // TODO: validate the result against the definition.outputs
+        return await (0, utils_1.runnableResponseStreamToObject)(result);
+    }
+};
+exports.PipelineAgent = PipelineAgent;
+exports.PipelineAgent = PipelineAgent = PipelineAgent_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])
+], PipelineAgent);
+function createPipelineAgentDefinition(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 processes = ordered_map_1.OrderedRecord.fromArray([]);
+    for (const p of options.processes || []) {
+        ordered_map_1.OrderedRecord.push(processes, {
+            id: (0, nanoid_1.nanoid)(),
+            name: p.name || p.runnable?.name,
+            runnable: { id: p.runnable.id },
+            input: Object.fromEntries(ordered_map_1.OrderedRecord.map(p.runnable.definition.inputs, (inputOfProcess) => {
+                const i = p.input?.[inputOfProcess.name || inputOfProcess.id];
+                if (!i) {
+                    if (inputOfProcess.required) {
+                        throw new Error(`Input ${inputOfProcess.name || inputOfProcess.id} for case ${p.runnable.name || p.runnable.id} is required`);
+                    }
+                    // ignore optional input
+                    return null;
+                }
+                const inputFromPipeline = ordered_map_1.OrderedRecord.find(inputs, (input) => input.name === i.fromVariable) ||
+                    ordered_map_1.OrderedRecord.find(processes, (p) => p.name === i.fromVariable);
+                if (!inputFromPipeline)
+                    throw new Error(`Input ${i.fromVariable} not found`);
+                return [
+                    inputOfProcess.id,
+                    {
+                        from: 'variable',
+                        fromVariableId: inputFromPipeline.id,
+                        fromVariablePropPath: i.fromVariablePropPath,
+                    },
+                ];
+            }).filter(is_non_nullable_1.isNonNullable)),
+        });
+    }
+    const outputs = ordered_map_1.OrderedRecord.fromArray(options.outputs.map((output) => {
+        const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === output.fromVariable) ||
+            ordered_map_1.OrderedRecord.find(processes, (p) => p.name === output.fromVariable);
+        if (!from)
+            throw new Error(`Output ${output.name} not found in inputs or processes`);
+        return {
+            id: (0, nanoid_1.nanoid)(),
+            name: output.name,
+            type: output.type,
+            required: output.required,
+            from: 'variable',
+            fromVariableId: from.id,
+            fromVariablePropPath: output.fromVariablePropPath,
+        };
+    }));
+    return {
+        id: options.id || options.name || (0, nanoid_1.nanoid)(),
+        name: options.name,
+        type: 'pipeline_agent',
+        inputs,
+        outputs,
+        processes,
+    };
+}

package/lib/cjs/runnable.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runnable = void 0;
+exports.isRunnableResponseDelta = isRunnableResponseDelta;
+exports.isRunnableResponseError = isRunnableResponseError;
+const ordered_map_1 = require("./utils/ordered-map");
+class Runnable {
+    definition;
+    constructor(definition) {
+        this.definition = definition;
+        this.inputs = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.inputs, (i) => [i.name || i.id, i]));
+        this.outputs = Object.fromEntries(ordered_map_1.OrderedRecord.map(definition.outputs, (i) => [i.name || i.id, i]));
+    }
+    get id() {
+        return this.definition.id;
+    }
+    get name() {
+        return this.definition.name;
+    }
+    inputs;
+    outputs;
+}
+exports.Runnable = Runnable;
+function isRunnableResponseDelta(chunk) {
+    return '$text' in chunk || 'delta' in chunk;
+}
+function isRunnableResponseError(chunk) {
+    return 'error' in chunk;
+}