@aigne/core 0.4.194 → 0.4.196

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

@@ -0,0 +1,76 @@
+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;
+import { nanoid } from 'nanoid';
+import { inject, injectable } from 'tsyringe';
+import { TYPES } from './constants';
+import { Runnable, } from './runnable';
+import { OrderedRecord, objectToRunnableResponseStream, runnableResponseStreamToObject } from './utils';
+let LocalFunctionAgent = LocalFunctionAgent_1 = class LocalFunctionAgent extends 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
+                : objectToRunnableResponseStream(result)
+            : result instanceof ReadableStream
+                ? runnableResponseStreamToObject(result)
+                : result;
+    }
+};
+LocalFunctionAgent = LocalFunctionAgent_1 = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.definition)),
+    __param(1, inject(TYPES.context)),
+    __metadata("design:paramtypes", [Object, Object])
+], LocalFunctionAgent);
+export { LocalFunctionAgent };
+export function createLocalFunctionAgentDefinition(options) {
+    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: nanoid(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    const outputs = OrderedRecord.fromArray(options.outputs?.map((i) => ({
+        id: nanoid(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    return {
+        id: options.id || options.name || nanoid(),
+        name: options.name,
+        type: 'local_function_agent',
+        inputs,
+        outputs,
+        function: options.function,
+    };
+}

package/lib/esm/memory.js

@@ -0,0 +1,27 @@
+import { camelCase, startCase } from 'lodash';
+import { Runnable } from './runnable';
+import { OrderedRecord } from './utils';
+export class Memory extends Runnable {
+    constructor() {
+        super({
+            id: 'memory',
+            type: 'memory',
+            name: 'Memory',
+            inputs: OrderedRecord.fromArray([]),
+            outputs: OrderedRecord.fromArray([]),
+        });
+    }
+}
+export class MemoryRunner extends Runnable {
+    constructor(name) {
+        const id = `${camelCase(name)}_runner`;
+        super({
+            id,
+            type: id,
+            name: `${startCase(name)} Runner`,
+            description: `${startCase(name)} Runner`,
+            inputs: OrderedRecord.fromArray([]),
+            outputs: OrderedRecord.fromArray([]),
+        });
+    }
+}

package/lib/esm/pipeline-agent.js

@@ -0,0 +1,192 @@
+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 PipelineAgent_1;
+import { get, isNil } from 'lodash';
+import { nanoid } from 'nanoid';
+import { inject, injectable } from 'tsyringe';
+import { StreamTextOutputName, TYPES } from './constants';
+import logger from './logger';
+import { Runnable, } from './runnable';
+import { runnableResponseStreamToObject } from './utils';
+import { isNonNullable } from './utils/is-non-nullable';
+import { OrderedRecord } from './utils/ordered-map';
+let PipelineAgent = PipelineAgent_1 = class PipelineAgent extends 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(OrderedRecord.map(definition.inputs, (i) => {
+                        const value = input[i.name || i.id];
+                        if (isNil(value))
+                            return null;
+                        return [i.id, value];
+                    }).filter(isNonNullable));
+                    const outputs = OrderedRecord.toArray(definition.outputs);
+                    const textStreamOutput = outputs.find((i) => i.name === StreamTextOutputName);
+                    let result = {};
+                    for (const process of OrderedRecord.iterator(processes)) {
+                        if (!process.runnable?.id) {
+                            logger.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 ? get(v, input.fromVariablePropPath) : v;
+                            }
+                            else {
+                                throw new Error('Unsupported input source');
+                            }
+                            return [targetInput.name, value];
+                        })
+                            .filter(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 !== 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(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 ? get(v, output.fromVariablePropPath) : v;
+                                        }
+                                        else {
+                                            throw new Error(`Unsupported output source ${output.from}`);
+                                        }
+                                        return [output.name, value];
+                                    }).filter(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 runnableResponseStreamToObject(result);
+    }
+};
+PipelineAgent = PipelineAgent_1 = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.definition)),
+    __param(1, inject(TYPES.context)),
+    __metadata("design:paramtypes", [Object, Object])
+], PipelineAgent);
+export { PipelineAgent };
+export function createPipelineAgentDefinition(options) {
+    const inputs = OrderedRecord.fromArray(options.inputs?.map((i) => ({
+        id: nanoid(),
+        name: i.name,
+        type: i.type,
+        required: i.required,
+    })));
+    const processes = OrderedRecord.fromArray([]);
+    for (const p of options.processes || []) {
+        OrderedRecord.push(processes, {
+            id: nanoid(),
+            name: p.name || p.runnable?.name,
+            runnable: { id: p.runnable.id },
+            input: Object.fromEntries(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 = OrderedRecord.find(inputs, (input) => input.name === i.fromVariable) ||
+                    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(isNonNullable)),
+        });
+    }
+    const outputs = OrderedRecord.fromArray(options.outputs.map((output) => {
+        const from = OrderedRecord.find(inputs, (i) => i.name === output.fromVariable) ||
+            OrderedRecord.find(processes, (p) => p.name === output.fromVariable);
+        if (!from)
+            throw new Error(`Output ${output.name} not found in inputs or processes`);
+        return {
+            id: nanoid(),
+            name: output.name,
+            type: output.type,
+            required: output.required,
+            from: 'variable',
+            fromVariableId: from.id,
+            fromVariablePropPath: output.fromVariablePropPath,
+        };
+    }));
+    return {
+        id: options.id || options.name || nanoid(),
+        name: options.name,
+        type: 'pipeline_agent',
+        inputs,
+        outputs,
+        processes,
+    };
+}

package/lib/esm/runnable.js

@@ -0,0 +1,23 @@
+import { OrderedRecord } from './utils/ordered-map';
+export class Runnable {
+    definition;
+    constructor(definition) {
+        this.definition = definition;
+        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]));
+    }
+    get id() {
+        return this.definition.id;
+    }
+    get name() {
+        return this.definition.name;
+    }
+    inputs;
+    outputs;
+}
+export function isRunnableResponseDelta(chunk) {
+    return '$text' in chunk || 'delta' in chunk;
+}
+export function isRunnableResponseError(chunk) {
+    return 'error' in chunk;
+}