@aigne/core 0.4.211-beta.2 → 1.0.0

package/lib/cjs/runnable.js

@@ -25,8 +25,8 @@ class Runnable {
 }
 exports.Runnable = Runnable;
 function isRunnableResponseDelta(chunk) {
-    return '$text' in chunk || 'delta' in chunk;
+    return "$text" in chunk || "delta" in chunk;
 }
 function isRunnableResponseError(chunk) {
-    return 'error' in chunk;
+    return "error" in chunk;
 }

package/lib/cjs/utils/fetch-open-api.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchOpenApi = void 0;
+exports.fetchOpenApi = fetchOpenApi;
 const ufo_1 = require("ufo");
 const constants_1 = require("./constants");
 const fetch_1 = require("./fetch");
-const fetchOpenApi = async (request) => {
+async function fetchOpenApi(request) {
     const cookie = request.cookies
         ? Object.entries(request.cookies)
             .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('; ')
+            .join("; ")
             .trim()
         : undefined;
     const controller = new AbortController();
@@ -16,15 +16,16 @@ const fetchOpenApi = async (request) => {
     const response = await fetch((0, ufo_1.withQuery)(request.url, request.query ?? {}), {
         method: request.method,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
             ...request.headers,
             ...(cookie && { cookie }),
         },
-        body: request.method.toLowerCase() !== 'get' && request.body ? JSON.stringify(request.body) : undefined,
-        credentials: request.cookies ? 'include' : 'same-origin',
+        body: request.method.toLowerCase() !== "get" && request.body
+            ? JSON.stringify(request.body)
+            : undefined,
+        credentials: request.cookies ? "include" : "same-origin",
         signal: controller.signal,
     }).finally(() => clearTimeout(abortTimer));
     await (0, fetch_1.checkFetchResponse)(response);
     return response.json();
-};
-exports.fetchOpenApi = fetchOpenApi;
+}

package/lib/cjs/utils/fetch.js

@@ -7,14 +7,15 @@ async function checkFetchResponse(result) {
         try {
             const json = await result.json();
             const msg = json.error?.message || json.message;
-            if (msg && typeof msg === 'string') {
+            if (msg && typeof msg === "string") {
                 message = msg;
             }
         }
         catch {
             // ignore
         }
-        throw new Error(message || `Failed to fetch url ${result.url} with status ${result.status}`);
+        throw new Error(message ||
+            `Failed to fetch url ${result.url} with status ${result.status}`);
     }
     return result;
 }

package/lib/cjs/utils/is-non-nullable.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNonNullable = isNonNullable;
 exports.isPropsNonNullable = isPropsNonNullable;
-const isNil_1 = __importDefault(require("lodash/isNil"));
+const isNil_1 = require("lodash/isNil");
 function isNonNullable(value) {
     return !(0, isNil_1.default)(value);
 }

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

@@ -1,29 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeHistoryMessages = mergeHistoryMessages;
 exports.memoriesToMessages = memoriesToMessages;
 exports.prepareMessages = prepareMessages;
-const omit_1 = __importDefault(require("lodash/omit"));
+const omit_1 = require("lodash/omit");
 const is_non_nullable_1 = require("./is-non-nullable");
 const mustache_utils_1 = require("./mustache-utils");
 const ordered_map_1 = require("./ordered-map");
 function mergeHistoryMessages(messages, history) {
-    const firstUserMessageIndex = messages.findIndex((m) => m.role === 'user');
+    const firstUserMessageIndex = messages.findIndex((m) => m.role === "user");
     if (firstUserMessageIndex >= 0) {
-        return [...messages.slice(0, firstUserMessageIndex), ...history, ...messages.slice(firstUserMessageIndex)];
+        return [
+            ...messages.slice(0, firstUserMessageIndex),
+            ...history,
+            ...messages.slice(firstUserMessageIndex),
+        ];
     }
     return [...history, ...messages];
 }
 function memoriesToMessages(memories, { primaryMemoryName } = {}) {
     const primary = (primaryMemoryName && memories[primaryMemoryName]) || [];
-    const otherMemories = primaryMemoryName ? (0, omit_1.default)(memories, primaryMemoryName) : memories;
+    const otherMemories = primaryMemoryName
+        ? (0, omit_1.default)(memories, primaryMemoryName)
+        : memories;
     const primaryMemory = primary
         .map((i) => {
-        const content = (0, mustache_utils_1.renderMessage)('{{memory}}', { memory: i.memory }).trim();
-        const role = ['user', 'assistant'].includes(i.metadata.role) ? i.metadata.role : undefined;
+        const content = (0, mustache_utils_1.renderMessage)("{{memory}}", { memory: i.memory }).trim();
+        const role = ["user", "assistant"].includes(i.metadata.role)
+            ? i.metadata.role
+            : undefined;
         if (!role || !content)
             return null;
         return { role, content };
@@ -31,10 +36,10 @@ function memoriesToMessages(memories, { primaryMemoryName } = {}) {
         .filter(is_non_nullable_1.isNonNullable);
     const memory = Object.values(otherMemories)
         .map((i) => i
-        .map((j) => (0, mustache_utils_1.renderMessage)('{{memory}}\n{{metadata}}', j).trim() || null)
+        .map((j) => (0, mustache_utils_1.renderMessage)("{{memory}}\n{{metadata}}", j).trim() || null)
         .filter(is_non_nullable_1.isNonNullable)
-        .join('\n'))
-        .join('\n');
+        .join("\n"))
+        .join("\n");
     return {
         primaryMemory,
         memory,
@@ -44,10 +49,12 @@ function prepareMessages(definition, input, memories) {
     const variables = { ...input, ...memories };
     const originalMessages = ordered_map_1.OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
         role,
-        content: typeof content === 'string' ? (0, mustache_utils_1.renderMessage)(content, variables) : content,
+        content: typeof content === "string"
+            ? (0, mustache_utils_1.renderMessage)(content, variables)
+            : content,
     }));
     if (!originalMessages.length)
-        throw new Error('Messages are required');
+        throw new Error("Messages are required");
     const { primaryMemory, memory } = memoriesToMessages(memories, {
         primaryMemoryName: ordered_map_1.OrderedRecord.find(definition.memories, (i) => i.id === definition.primaryMemoryId)?.name,
     });
@@ -55,13 +62,13 @@ function prepareMessages(definition, input, memories) {
     // Add memory to a system message
     if (memory) {
         const message = {
-            role: 'system',
+            role: "system",
             content: `\
         Here are the memories about the user:
         ${memory}
         `,
         };
-        const lastSystemMessageIndex = messagesWithMemory.findLastIndex((i) => i.role === 'assistant');
+        const lastSystemMessageIndex = messagesWithMemory.findLastIndex((i) => i.role === "assistant");
         messagesWithMemory.splice(lastSystemMessageIndex + 1, 0, message);
     }
     // Add primary memory to messages

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

@@ -1,14 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderMessage = renderMessage;
-const mustache_1 = __importDefault(require("mustache"));
+const mustache_1 = require("mustache");
 function renderMessage(template, variables) {
     return mustache_1.default.render(template, variables, undefined, {
         escape: (v) => {
-            return typeof v === 'object' ? JSON.stringify(v) : v;
+            return typeof v === "object" ? JSON.stringify(v) : v;
         },
     });
 }

package/lib/cjs/utils/open-api-parameter.js

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatOpenAPIRequest = formatOpenAPIRequest;
 const lodash_1 = require("lodash");
-const logger_1 = __importDefault(require("../logger"));
+const logger_1 = require("../logger");
 const ordered_map_1 = require("./ordered-map");
 async function formatOpenAPIRequest(api, inputs, input) {
     const { url, method, ...inputParams } = processParameters(api, inputs, input);
-    logger_1.default.debug('inputParams', inputParams);
+    logger_1.default.debug("inputParams", inputParams);
     const authParams = await getAuthParams(api.auth);
-    logger_1.default.debug('authParams', authParams);
+    logger_1.default.debug("authParams", authParams);
     return {
         url,
         method,
@@ -26,18 +23,18 @@ async function formatOpenAPIRequest(api, inputs, input) {
 async function getAuthParams(auth) {
     if (!auth)
         return {};
-    if (auth.type === 'custom') {
+    if (auth.type === "custom") {
         return await auth.getValue();
     }
     const { type, key, token } = auth;
     switch (auth.in) {
-        case 'query':
-            return { query: { [key || 'token']: token } };
-        case 'cookie':
-            return { cookies: { [key || 'token']: token } };
+        case "query":
+            return { query: { [key || "token"]: token } };
+        case "cookie":
+            return { cookies: { [key || "token"]: token } };
         default: {
-            const prefix = type === 'bearer' ? 'Bearer ' : type === 'basic' ? 'Basic ' : '';
-            return { headers: { [key || 'Authorization']: `${prefix}${token}` } };
+            const prefix = type === "bearer" ? "Bearer " : type === "basic" ? "Basic " : "";
+            return { headers: { [key || "Authorization"]: `${prefix}${token}` } };
         }
     }
 }
@@ -50,35 +47,35 @@ function processParameters(api, inputs, input) {
         cookies: {},
         body: {},
     };
-    Object.entries(input).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(input)) {
         const schema = ordered_map_1.OrderedRecord.find(inputs, (x) => x.name === key);
         if (!schema)
-            return;
+            continue;
         switch (schema.in) {
-            case 'query':
+            case "query":
                 result.query[key] = value;
                 break;
-            case 'header':
+            case "header":
                 result.headers[key] = value;
                 break;
-            case 'cookie':
+            case "cookie":
                 result.cookies[key] = value;
                 break;
-            case 'body':
+            case "body":
                 result.body[key] = value;
                 break;
-            case 'path':
+            case "path":
                 result.url = result.url.replace(`{${key}}`, String(value));
                 break;
             default:
                 // 没有指定 in 的情况
-                if (result.method.toLowerCase() === 'get') {
+                if (result.method.toLowerCase() === "get") {
                     result.query[key] = value;
                 }
                 else {
                     result.body[key] = value;
                 }
         }
-    });
+    }
     return result;
 }

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

@@ -15,11 +15,11 @@ function objectToRunnableResponseStream(obj) {
     });
 }
 async function runnableResponseStreamToObject(stream) {
-    let $text = '';
+    let $text = "";
     const result = {};
     for await (const value of stream) {
         if ((0, runnable_1.isRunnableResponseDelta)(value)) {
-            $text += value.$text || '';
+            $text += value.$text || "";
             Object.assign(result, value.delta);
         }
     }
@@ -35,16 +35,17 @@ async function runnableResponseStreamToObject(stream) {
  * @returns The runnable output stream or object
  */
 async function extractOutputsFromRunnableOutput(output, resolve) {
-    if (output instanceof ReadableStream || isAsyncGenerator(output)) {
+    if (output instanceof ReadableStream ||
+        isAsyncGenerator(output)) {
         return new ReadableStream({
             async start(controller) {
                 try {
                     const result = {};
-                    let $text = '';
+                    let $text = "";
                     for await (const value of output) {
                         if ((0, runnable_1.isRunnableResponseDelta)(value)) {
                             controller.enqueue(value);
-                            $text += value.$text || '';
+                            $text += value.$text || "";
                             Object.assign(result, value.delta);
                         }
                     }

package/lib/cjs/utils/structured-output-schema.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.outputsToJsonSchema = outputsToJsonSchema;
-const omitBy_1 = __importDefault(require("lodash/omitBy"));
+const omitBy_1 = require("lodash/omitBy");
 const is_non_nullable_1 = require("./is-non-nullable");
 const ordered_map_1 = require("./ordered-map");
 function outputsToJsonSchema(outputs) {
     const outputToSchema = (output) => {
-        const properties = output.type === 'object' && output.properties?.$indexes.length
+        const properties = output.type === "object" && output.properties?.$indexes.length
             ? ordered_map_1.OrderedRecord.map(output.properties, (property) => {
                 if (!property.name)
                     return null;
@@ -25,15 +22,19 @@ function outputsToJsonSchema(outputs) {
             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,
+            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)
+                ? properties
+                    .filter((i) => i.property.required)
+                    .map((i) => i.property.name)
                 : undefined,
         }, (v) => v === undefined);
     };
     return outputToSchema({
-        type: 'object',
+        type: "object",
         properties: outputs,
     });
 }

package/lib/esm/agent.js

@@ -1,18 +1,18 @@
-import logger from './logger';
-import { Runnable, } from './runnable';
-import { OrderedRecord, extractOutputsFromRunnableOutput, isAsyncGenerator, isNonNullable, objectToRunnableResponseStream, renderMessage, runnableResponseStreamToObject, } from './utils';
+import logger from "./logger";
+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') {
+        if (query?.from === "variable") {
             const i = 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 renderMessage('{{value}}', { value });
+            return 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.
@@ -27,7 +27,11 @@ export class Agent extends 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],
@@ -52,7 +56,9 @@ export class Agent extends Runnable {
         }));
     }
     async run(input, options) {
-        logger.debug(`AIGNE core: run agent ${this.name || this.id} with`, { input });
+        logger.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) {
@@ -62,7 +68,9 @@ export class Agent extends Runnable {
                 : objectToRunnableResponseStream(processResult);
             return extractOutputsFromRunnableOutput(stream, async (result) => {
                 // TODO: validate result against outputs schema
-                logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, { result });
+                logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
+                    result,
+                });
                 await this.onResult(result);
             });
         }
@@ -71,7 +79,9 @@ export class Agent extends Runnable {
             : Symbol.asyncIterator in processResult
                 ? await runnableResponseStreamToObject(processResult)
                 : processResult;
-        logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, { result });
+        logger.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/esm/constants.js

@@ -1,7 +1,7 @@
 export const 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"),
 };
-export const StreamTextOutputName = '$text';
+export const StreamTextOutputName = "$text";

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

@@ -1,5 +1,5 @@
-import { nanoid } from 'nanoid';
-import { OrderedRecord } from '../utils/ordered-map';
+import { nanoid } from "nanoid";
+import { OrderedRecord } from "../utils/ordered-map";
 export function schemaToDataType(dataType) {
     return OrderedRecord.fromArray(Object.entries(dataType).map(([name, schema]) => {
         const base = {
@@ -8,32 +8,33 @@ export 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 && OrderedRecord.find(schemaToDataType({ items: schema.items }), (i) => i.name === 'items'),
+                    type: "array",
+                    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/definitions/memory.js

@@ -1,5 +1,5 @@
-import { nanoid } from 'nanoid';
-import { OrderedRecord } from '../utils';
+import { nanoid } from "nanoid";
+import { OrderedRecord } from "../utils";
 export function toRunnableMemories(agentName, inputs, memories) {
     return OrderedRecord.fromArray(Object.entries(memories).map(([name, { memory, query, options }]) => {
         const queryFromVariable = query?.fromVariable
@@ -11,7 +11,9 @@ export function toRunnableMemories(agentName, inputs, memories) {
             id: name || nanoid(),
             name,
             memory,
-            query: queryFromVariable ? { from: 'variable', fromVariableId: queryFromVariable.id } : undefined,
+            query: queryFromVariable
+                ? { from: "variable", fromVariableId: queryFromVariable.id }
+                : undefined,
             options,
         };
     }));

package/lib/esm/function-agent.js

@@ -10,13 +10,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-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 { 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";
 let FunctionAgent = class FunctionAgent extends Agent {
     definition;
     runner;
@@ -30,11 +29,11 @@ let FunctionAgent = class FunctionAgent extends 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,
@@ -50,7 +49,7 @@ FunctionAgent = __decorate([
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
     __param(2, inject(TYPES.functionRunner)),
-    __metadata("design:paramtypes", [Object, Object, FunctionRunner])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], FunctionAgent);
 export { FunctionAgent };
 export function create({ context, ...options }) {
@@ -61,7 +60,7 @@ export function create({ context, ...options }) {
     return new FunctionAgent({
         id: agentId,
         name: options.name,
-        type: 'function_agent',
+        type: "function_agent",
         inputs,
         outputs,
         memories,

package/lib/esm/function-runner.js

@@ -1,25 +1,25 @@
-import { Agent } from './agent';
-import { OrderedRecord } from './utils';
+import { Agent } from "./agent";
+import { OrderedRecord } from "./utils";
 export class FunctionRunner extends 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: 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: OrderedRecord.fromArray([
                 {
-                    id: 'result',
-                    name: 'result',
-                    type: 'object',
+                    id: "result",
+                    name: "result",
+                    type: "object",
                 },
             ]),
         }, context);