@aigne/core 0.4.211-beta.2 → 1.0.1

package/lib/cjs/agent.js

@@ -1,24 +1,21 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
-const logger_1 = __importDefault(require("./logger"));
+const logger_1 = require("./logger");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
 class Agent extends runnable_1.Runnable {
     async getMemoryQuery(input, query) {
-        if (query?.from === 'variable') {
+        if (query?.from === "variable") {
             const i = utils_1.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 (0, utils_1.renderMessage)('{{value}}', { value });
+            return (0, utils_1.renderMessage)("{{value}}", { value });
         }
         return Object.entries(input)
             .map(([key, value]) => `${key} ${value}`)
-            .join('\n');
+            .join("\n");
     }
     /**
      * Load memories that are defined in the agent definition.
@@ -33,7 +30,11 @@ class Agent extends runnable_1.Runnable {
             if (!name || !memory)
                 return null;
             const q = await this.getMemoryQuery(input, query);
-            const { results: memories } = await memory.search(q, { ...options, userId, sessionId });
+            const { results: memories } = await memory.search(q, {
+                ...options,
+                userId,
+                sessionId,
+            });
             return [
                 [id, memories],
                 [name, memories],
@@ -58,7 +59,9 @@ class Agent extends runnable_1.Runnable {
         }));
     }
     async run(input, options) {
-        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} with`, { input });
+        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} with`, {
+            input,
+        });
         const memories = await this.loadMemories(input, this.context);
         const processResult = await this.process(input, { ...options, memories });
         if (options?.stream) {
@@ -68,7 +71,9 @@ class Agent extends runnable_1.Runnable {
                 : (0, utils_1.objectToRunnableResponseStream)(processResult);
             return (0, utils_1.extractOutputsFromRunnableOutput)(stream, async (result) => {
                 // TODO: validate result against outputs schema
-                logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, { result });
+                logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
+                    result,
+                });
                 await this.onResult(result);
             });
         }
@@ -77,7 +82,9 @@ class Agent extends runnable_1.Runnable {
             : Symbol.asyncIterator in processResult
                 ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
                 : processResult;
-        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, { result });
+        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
+            result,
+        });
         // TODO: validate result against outputs schema
         await this.onResult(result);
         return result;

package/lib/cjs/constants.js

@@ -2,9 +2,9 @@
 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'),
-    functionRunner: Symbol.for('AIGNE_FUNCTION_RUNNER'),
+    context: Symbol.for("AIGNE_CONTEXT"),
+    definition: Symbol.for("AIGNE_DEFINITION"),
+    llmModel: Symbol.for("AIGNE_LLM_MODEL"),
+    functionRunner: Symbol.for("AIGNE_FUNCTION_RUNNER"),
 };
-exports.StreamTextOutputName = '$text';
+exports.StreamTextOutputName = "$text";

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

@@ -11,32 +11,33 @@ function schemaToDataType(dataType) {
             name,
         };
         switch (schema.type) {
-            case 'string':
+            case "string":
                 return {
                     ...base,
-                    type: 'string',
+                    type: "string",
                 };
-            case 'number':
+            case "number":
                 return {
                     ...base,
-                    type: 'number',
+                    type: "number",
                 };
-            case 'boolean':
+            case "boolean":
                 return {
                     ...base,
-                    type: 'boolean',
+                    type: "boolean",
                 };
-            case 'object':
+            case "object":
                 return {
                     ...base,
-                    type: 'object',
+                    type: "object",
                     properties: schema.properties && schemaToDataType(schema.properties),
                 };
-            case 'array':
+            case "array":
                 return {
                     ...base,
-                    type: 'array',
-                    items: schema.items && ordered_map_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                    type: "array",
+                    items: schema.items &&
+                        ordered_map_1.OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === "items"),
                 };
             default: {
                 throw new Error(`Unknown data type: ${schema.type}`);

package/lib/cjs/definitions/memory.js

@@ -14,7 +14,9 @@ function toRunnableMemories(agentName, inputs, memories) {
             id: name || (0, nanoid_1.nanoid)(),
             name,
             memory,
-            query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
+            query: queryFromVariable
+                ? { from: "variable", fromVariableId: queryFromVariable.id }
+                : undefined,
             options,
         };
     }));

package/lib/cjs/function-agent.js

@@ -20,7 +20,6 @@ const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
-const function_runner_1 = require("./function-runner");
 let FunctionAgent = class FunctionAgent extends agent_1.Agent {
     definition;
     runner;
@@ -34,11 +33,11 @@ let FunctionAgent = class FunctionAgent extends agent_1.Agent {
     async process(input, options) {
         const { definition: { language, code, ...definition }, runner, context, } = this;
         if (!runner)
-            throw new Error('Function runner is required');
+            throw new Error("Function runner is required");
         if (!code)
-            throw new Error('Code is required');
+            throw new Error("Code is required");
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         return await runner.run({
             name: definition.name || definition.id,
             language,
@@ -55,7 +54,7 @@ exports.FunctionAgent = FunctionAgent = __decorate([
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, Object, function_runner_1.FunctionRunner])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], FunctionAgent);
 function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
@@ -65,7 +64,7 @@ function create({ context, ...options }) {
     return new FunctionAgent({
         id: agentId,
         name: options.name,
-        type: 'function_agent',
+        type: "function_agent",
         inputs,
         outputs,
         memories,

package/lib/cjs/function-runner.js

@@ -6,23 +6,23 @@ const utils_1 = require("./utils");
 class FunctionRunner extends agent_1.Agent {
     constructor(context) {
         super({
-            id: 'function_runner',
-            type: 'function_runner',
-            name: 'Function Runner',
-            description: 'Run a function',
+            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' },
-                { id: 'code', name: 'code', type: 'string', required: true },
-                { id: 'input', name: 'input', type: 'object', required: true },
-                { id: 'memories', name: 'memories', type: 'object', required: true },
-                { id: 'context', name: 'context', type: 'object', required: true },
+                { id: "name", name: "name", type: "string", required: true },
+                { id: "language", name: "language", type: "string" },
+                { id: "code", name: "code", type: "string", required: true },
+                { 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: utils_1.OrderedRecord.fromArray([
                 {
-                    id: 'result',
-                    name: 'result',
-                    type: 'object',
+                    id: "result",
+                    name: "result",
+                    type: "object",
                 },
             ]),
         }, context);

package/lib/cjs/llm-agent.js

@@ -19,7 +19,6 @@ const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
-const llm_model_1 = require("./llm-model");
 const message_utils_1 = require("./utils/message-utils");
 const mustache_utils_1 = require("./utils/mustache-utils");
 const ordered_map_1 = require("./utils/ordered-map");
@@ -37,17 +36,17 @@ let LLMAgent = class LLMAgent extends agent_1.Agent {
     async *process(input, options) {
         const { definition, model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
         const llmInputs = {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
         };
-        let $text = '';
+        let $text = "";
         const hasTextOutput = ordered_map_1.OrderedRecord.find(definition.outputs, (i) => i.name === constants_1.StreamTextOutputName);
         if (hasTextOutput) {
             for await (const chunk of await this.runWithTextOutput(llmInputs)) {
-                $text += chunk.$text || '';
+                $text += chunk.$text || "";
                 yield { $text: chunk.$text };
             }
         }
@@ -56,37 +55,39 @@ let LLMAgent = class LLMAgent extends agent_1.Agent {
             yield { delta: json };
         await this.updateMemories([
             ...originalMessages,
-            { role: 'assistant', content: (0, mustache_utils_1.renderMessage)('{{$text}}\n{{json}}', { $text, json }).trim() },
+            {
+                role: "assistant",
+                content: (0, mustache_utils_1.renderMessage)("{{$text}}\n{{json}}", { $text, json }).trim(),
+            },
         ]);
     }
     async runWithStructuredOutput(llmInputs) {
-        const jsonOutputs = ordered_map_1.OrderedRecord.filter(this.definition.outputs, (i) => i.name !== constants_1.StreamTextOutputName // ignore `$text` output
-        );
+        const jsonOutputs = ordered_map_1.OrderedRecord.filter(this.definition.outputs, (i) => i.name !== constants_1.StreamTextOutputName);
         if (!jsonOutputs.length)
             return null;
         const schema = (0, structured_output_schema_1.outputsToJsonSchema)(ordered_map_1.OrderedRecord.fromArray(jsonOutputs));
         const { model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         const response = await model.run({
             ...llmInputs,
             responseFormat: {
-                type: 'json_schema',
+                type: "json_schema",
                 jsonSchema: {
-                    name: 'output',
+                    name: "output",
                     schema,
                     strict: true,
                 },
             },
         });
         if (!response.$text)
-            throw new Error('No text in JSON mode response');
+            throw new Error("No text in JSON mode response");
         return JSON.parse(response.$text);
     }
     async runWithTextOutput(llmInputs) {
         const { model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         return model.run(llmInputs, { stream: true });
     }
 };
@@ -96,7 +97,7 @@ exports.LLMAgent = LLMAgent = __decorate([
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, Object, llm_model_1.LLMModel])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMAgent);
 /**
  * Create LLMAgent definition.
@@ -112,7 +113,7 @@ function create({ context, ...options }) {
         .filter(([, i]) => i.primary)
         .map(([name]) => name);
     if (primaryMemoryNames && primaryMemoryNames.length > 1) {
-        throw new Error('Only one primary memory is allowed');
+        throw new Error("Only one primary memory is allowed");
     }
     const messages = ordered_map_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
         id: (0, nanoid_1.nanoid)(),
@@ -122,7 +123,7 @@ function create({ context, ...options }) {
     return new LLMAgent({
         id: agentId,
         name: options.name,
-        type: 'llm_agent',
+        type: "llm_agent",
         inputs,
         outputs,
         primaryMemoryId: primaryMemoryNames?.at(0),

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

@@ -18,7 +18,6 @@ const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const memory_1 = require("./definitions/memory");
-const llm_model_1 = require("./llm-model");
 const utils_1 = require("./utils");
 const message_utils_1 = require("./utils/message-utils");
 let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
@@ -34,18 +33,18 @@ let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
     async process(input, options) {
         const { definition, context, model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         const { originalMessages, messagesWithMemory } = (0, message_utils_1.prepareMessages)(definition, input, options.memories);
         const cases = await Promise.all(utils_1.OrderedRecord.map(definition.cases, async (t) => {
             if (!t.runnable?.id)
-                throw new Error('Runnable is required');
+                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');
+                throw new Error("Case name is required");
             return { name, description: t.description, runnable };
         }));
         const llmInputs = {
@@ -54,7 +53,7 @@ let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
             tools: cases.map((t) => {
                 // TODO: auto generate parameters by llm model if needed
                 return {
-                    type: 'function',
+                    type: "function",
                     function: {
                         name: t.name,
                         description: t.description,
@@ -62,21 +61,24 @@ let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
                     },
                 };
             }),
-            toolChoice: 'required',
+            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');
+            throw new Error("No any runnable called");
         const caseToCall = cases.find((i) => i.name === functionNameToCall);
         if (!caseToCall)
-            throw new Error('Case not found');
+            throw new Error("Case not found");
         // TODO: check result structure and omit undefined values
         const output = await caseToCall.runnable.run(input, { stream: true });
         return (0, utils_1.extractOutputsFromRunnableOutput)(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
-            { role: 'assistant', content: (0, utils_1.renderMessage)('{{$text}}\n{{json}}', { $text, json }).trim() },
+            {
+                role: "assistant",
+                content: (0, utils_1.renderMessage)("{{$text}}\n{{json}}", { $text, json }).trim(),
+            },
         ]));
     }
 };
@@ -86,7 +88,7 @@ exports.LLMDecisionAgent = LLMDecisionAgent = __decorate([
     __param(0, (0, tsyringe_1.inject)(constants_1.TYPES.definition)),
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, Object, llm_model_1.LLMModel])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMDecisionAgent);
 function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
@@ -103,7 +105,7 @@ function create({ context, ...options }) {
         .filter(([, i]) => i.primary)
         .map(([name]) => name);
     if (primaryMemoryNames && primaryMemoryNames.length > 1) {
-        throw new Error('Only one primary memory is allowed');
+        throw new Error("Only one primary memory is allowed");
     }
     const messages = utils_1.OrderedRecord.fromArray(options.messages?.map((i) => ({
         id: (0, nanoid_1.nanoid)(),
@@ -113,7 +115,7 @@ function create({ context, ...options }) {
     return new LLMDecisionAgent({
         id: agentId,
         name: options.name,
-        type: 'llm_decision_agent',
+        type: "llm_decision_agent",
         inputs,
         outputs,
         messages,

package/lib/cjs/llm-model.js

@@ -6,20 +6,20 @@ const utils_1 = require("./utils");
 class LLMModel extends agent_1.Agent {
     constructor(context) {
         super({
-            id: 'llm_model',
-            type: 'llm_model',
-            name: 'LLM Model',
-            description: 'Run a LLM model',
+            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' },
+                { 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' },
+                { id: "$text", name: "$text", type: "string" },
+                { id: "toolCalls", name: "toolCalls", type: "object" },
             ]),
         }, context);
     }

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

@@ -29,9 +29,9 @@ let LocalFunctionAgent = class LocalFunctionAgent extends agent_1.Agent {
     async process(input, options) {
         const { definition: { function: func }, context, } = this;
         if (!func)
-            throw new Error('Function is required');
+            throw new Error("Function is required");
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         return await func(input, { context, memories: options.memories });
     }
 };
@@ -50,7 +50,7 @@ function create({ context, ...options }) {
     return new LocalFunctionAgent({
         id: agentId,
         name: options.name,
-        type: 'local_function_agent',
+        type: "local_function_agent",
         inputs,
         outputs,
         memories,

package/lib/cjs/memorable.js

@@ -7,9 +7,9 @@ const utils_1 = require("./utils");
 class Memorable extends runnable_1.Runnable {
     constructor() {
         super({
-            id: 'memory',
-            type: 'memory',
-            name: 'Memory',
+            id: "memory",
+            type: "memory",
+            name: "Memory",
             inputs: utils_1.OrderedRecord.fromArray([]),
             outputs: utils_1.OrderedRecord.fromArray([]),
         });

package/lib/cjs/open-api-agent.js

@@ -28,13 +28,13 @@ let OpenAPIAgent = class OpenAPIAgent extends agent_1.Agent {
         this.definition = definition;
     }
     async process(input) {
-        const { url, method = 'get', auth, inputs } = this.definition;
+        const { url, method = "get", auth, inputs } = this.definition;
         if (!url)
-            throw new Error('API url is required');
+            throw new Error("API url is required");
         const request = await (0, open_api_parameter_1.formatOpenAPIRequest)({ url, method, auth }, inputs, input);
         return this.fetch(request);
     }
-    fetch(request) {
+    async fetch(request) {
         return (0, fetch_open_api_1.fetchOpenApi)(request);
     }
 };
@@ -52,7 +52,7 @@ function create({ context, ...options }) {
     return new OpenAPIAgent({
         id: agentId,
         name: options.name,
-        type: 'open_api_agent',
+        type: "open_api_agent",
         inputs,
         outputs,
         url: options.url,

package/lib/cjs/pipeline-agent.js

@@ -11,9 +11,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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PipelineAgent = void 0;
 const lodash_1 = require("lodash");
@@ -23,7 +20,7 @@ const agent_1 = require("./agent");
 const constants_1 = require("./constants");
 const data_type_schema_1 = require("./definitions/data-type-schema");
 const memory_1 = require("./definitions/memory");
-const logger_1 = __importDefault(require("./logger"));
+const logger_1 = require("./logger");
 const is_non_nullable_1 = require("./utils/is-non-nullable");
 const ordered_map_1 = require("./utils/ordered-map");
 let PipelineAgent = class PipelineAgent extends agent_1.Agent {
@@ -36,10 +33,10 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
     async process(input, options) {
         const { definition, context } = this;
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         const { processes } = definition;
         if (!processes?.$indexes.length) {
-            throw new Error('No processes defined');
+            throw new Error("No processes defined");
         }
         return new ReadableStream({
             async start(controller) {
@@ -59,7 +56,7 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
                     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);
+                            logger_1.default.warn("Runnable id is required for process", process);
                             continue;
                         }
                         const runnable = await context.resolve(process.runnable.id);
@@ -71,18 +68,21 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
                             if (!targetInput?.name)
                                 return null;
                             let value;
-                            if (input.from === 'variable') {
+                            if (input.from === "variable") {
                                 const v = variables[input.fromVariableId];
-                                value = input.fromVariablePropPath?.length ? (0, lodash_1.get)(v, input.fromVariablePropPath) : v;
+                                value = input.fromVariablePropPath?.length
+                                    ? (0, lodash_1.get)(v, input.fromVariablePropPath)
+                                    : v;
                             }
                             else {
-                                throw new Error('Unsupported input source');
+                                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 needRespondTextStream = textStreamOutput?.from === "variable" &&
+                            textStreamOutput.fromVariableId === process.id;
                         // const needRespondJsonStream = outputs.some(
                         //   (i) => i.name !== StreamTextOutputName && i.from === 'variable' && i.fromVariableId === process.id
                         // );
@@ -90,7 +90,9 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
                         variables[process.id] = processResult;
                         for await (const chunk of stream) {
                             if (chunk.$text) {
-                                Object.assign(processResult, { $text: (processResult.$text || '') + chunk.$text });
+                                Object.assign(processResult, {
+                                    $text: (processResult.$text || "") + chunk.$text,
+                                });
                                 if (needRespondTextStream) {
                                     controller.enqueue({ $text: chunk.$text });
                                 }
@@ -105,9 +107,11 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
                                     if (output.name === constants_1.StreamTextOutputName)
                                         return null;
                                     let value;
-                                    if (output.from === 'variable') {
+                                    if (output.from === "variable") {
                                         const v = variables[output.fromVariableId];
-                                        value = output.fromVariablePropPath?.length ? (0, lodash_1.get)(v, output.fromVariablePropPath) : v;
+                                        value = output.fromVariablePropPath?.length
+                                            ? (0, lodash_1.get)(v, output.fromVariablePropPath)
+                                            : v;
                                     }
                                     else {
                                         throw new Error(`Unsupported output source ${output.from}`);
@@ -163,7 +167,7 @@ function create({ context, ...options }) {
                 return [
                     inputOfProcess.id,
                     {
-                        from: 'variable',
+                        from: "variable",
                         fromVariableId: inputFromPipeline.id,
                         fromVariablePropPath: i.fromVariablePropPath,
                     },
@@ -177,12 +181,17 @@ function create({ context, ...options }) {
             ordered_map_1.OrderedRecord.find(processes, (p) => p.name === fromVariable);
         if (!from)
             throw new Error(`Output ${output.name} not found in inputs or processes`);
-        return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
+        return {
+            ...output,
+            from: "variable",
+            fromVariableId: from.id,
+            fromVariablePropPath,
+        };
     }));
     return new PipelineAgent({
         id: agentId,
         name: options.name,
-        type: 'pipeline_agent',
+        type: "pipeline_agent",
         inputs,
         memories,
         outputs,