@aigne/core 0.4.211-beta.2 → 1.0.0

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

@@ -1,4 +1,4 @@
-import isNil from 'lodash/isNil';
+import isNil from "lodash/isNil";
 export function isNonNullable(value) {
     return !isNil(value);
 }

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

@@ -1,21 +1,29 @@
-import omit from 'lodash/omit';
-import { isNonNullable } from './is-non-nullable';
-import { renderMessage } from './mustache-utils';
-import { OrderedRecord } from './ordered-map';
+import omit from "lodash/omit";
+import { isNonNullable } from "./is-non-nullable";
+import { renderMessage } from "./mustache-utils";
+import { OrderedRecord } from "./ordered-map";
 export 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];
 }
 export function memoriesToMessages(memories, { primaryMemoryName } = {}) {
     const primary = (primaryMemoryName && memories[primaryMemoryName]) || [];
-    const otherMemories = primaryMemoryName ? omit(memories, primaryMemoryName) : memories;
+    const otherMemories = primaryMemoryName
+        ? omit(memories, primaryMemoryName)
+        : memories;
     const primaryMemory = primary
         .map((i) => {
-        const content = renderMessage('{{memory}}', { memory: i.memory }).trim();
-        const role = ['user', 'assistant'].includes(i.metadata.role) ? i.metadata.role : undefined;
+        const content = 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 };
@@ -23,10 +31,10 @@ export function memoriesToMessages(memories, { primaryMemoryName } = {}) {
         .filter(isNonNullable);
     const memory = Object.values(otherMemories)
         .map((i) => i
-        .map((j) => renderMessage('{{memory}}\n{{metadata}}', j).trim() || null)
+        .map((j) => renderMessage("{{memory}}\n{{metadata}}", j).trim() || null)
         .filter(isNonNullable)
-        .join('\n'))
-        .join('\n');
+        .join("\n"))
+        .join("\n");
     return {
         primaryMemory,
         memory,
@@ -36,10 +44,12 @@ export function prepareMessages(definition, input, memories) {
     const variables = { ...input, ...memories };
     const originalMessages = OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
         role,
-        content: typeof content === 'string' ? renderMessage(content, variables) : content,
+        content: typeof content === "string"
+            ? 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: OrderedRecord.find(definition.memories, (i) => i.id === definition.primaryMemoryId)?.name,
     });
@@ -47,13 +57,13 @@ export 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/esm/utils/mustache-utils.js

@@ -1,8 +1,8 @@
-import Mustache from 'mustache';
+import Mustache from "mustache";
 export function renderMessage(template, variables) {
     return Mustache.render(template, variables, undefined, {
         escape: (v) => {
-            return typeof v === 'object' ? JSON.stringify(v) : v;
+            return typeof v === "object" ? JSON.stringify(v) : v;
         },
     });
 }

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

@@ -1,11 +1,11 @@
-import { isEmpty, omitBy } from 'lodash';
-import logger from '../logger';
-import { OrderedRecord } from './ordered-map';
+import { isEmpty, omitBy } from "lodash";
+import logger from "../logger";
+import { OrderedRecord } from "./ordered-map";
 export async function formatOpenAPIRequest(api, inputs, input) {
     const { url, method, ...inputParams } = processParameters(api, inputs, input);
-    logger.debug('inputParams', inputParams);
+    logger.debug("inputParams", inputParams);
     const authParams = await getAuthParams(api.auth);
-    logger.debug('authParams', authParams);
+    logger.debug("authParams", authParams);
     return {
         url,
         method,
@@ -20,18 +20,18 @@ export 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}` } };
         }
     }
 }
@@ -44,35 +44,35 @@ function processParameters(api, inputs, input) {
         cookies: {},
         body: {},
     };
-    Object.entries(input).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(input)) {
         const schema = 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/esm/utils/stream-utils.js

@@ -1,4 +1,4 @@
-import { isRunnableResponseDelta } from '../runnable';
+import { isRunnableResponseDelta, } from "../runnable";
 export function objectToRunnableResponseStream(obj) {
     return new ReadableStream({
         start(controller) {
@@ -8,11 +8,11 @@ export function objectToRunnableResponseStream(obj) {
     });
 }
 export async function runnableResponseStreamToObject(stream) {
-    let $text = '';
+    let $text = "";
     const result = {};
     for await (const value of stream) {
         if (isRunnableResponseDelta(value)) {
-            $text += value.$text || '';
+            $text += value.$text || "";
             Object.assign(result, value.delta);
         }
     }
@@ -28,16 +28,17 @@ export async function runnableResponseStreamToObject(stream) {
  * @returns The runnable output stream or object
  */
 export 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 (isRunnableResponseDelta(value)) {
                             controller.enqueue(value);
-                            $text += value.$text || '';
+                            $text += value.$text || "";
                             Object.assign(result, value.delta);
                         }
                     }

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

@@ -1,9 +1,9 @@
-import omitBy from 'lodash/omitBy';
-import { isNonNullable } from './is-non-nullable';
-import { OrderedRecord } from './ordered-map';
+import omitBy from "lodash/omitBy";
+import { isNonNullable } from "./is-non-nullable";
+import { OrderedRecord } from "./ordered-map";
 export function outputsToJsonSchema(outputs) {
     const outputToSchema = (output) => {
-        const properties = output.type === 'object' && output.properties?.$indexes.length
+        const properties = output.type === "object" && output.properties?.$indexes.length
             ? OrderedRecord.map(output.properties, (property) => {
                 if (!property.name)
                     return null;
@@ -19,15 +19,19 @@ export 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/types/agent.d.ts

@@ -1,6 +1,6 @@
-import { Context, ContextState } from './context';
-import { MemoryItemWithScore, MemoryMessage } from './memorable';
-import { RunOptions, Runnable, RunnableResponse, RunnableResponseChunk, RunnableResponseStream } from './runnable';
+import type { Context, ContextState } from "./context";
+import type { MemoryItemWithScore, MemoryMessage } from "./memorable";
+import { type RunOptions, Runnable, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
 export interface AgentProcessOptions<Memories extends {
     [name: string]: MemoryItemWithScore[];
 }> {

package/lib/types/context.d.ts

@@ -1,5 +1,5 @@
-import type { LLMModelConfiguration } from './llm-model';
-import { Runnable, RunnableDefinition } from './runnable';
+import type { LLMModelConfiguration } from "./llm-model";
+import type { Runnable, RunnableDefinition } from "./runnable";
 export interface ContextState {
     userId?: string;
     sessionId?: string;

package/lib/types/definitions/data-type-schema.d.ts

@@ -1,6 +1,6 @@
-import { MakeNullablePropertyOptional } from '../utils/nullable';
-import { OrderedRecord } from '../utils/ordered-map';
-import { DataType } from './data-type';
+import type { MakeNullablePropertyOptional } from "../utils/nullable";
+import { OrderedRecord } from "../utils/ordered-map";
+import type { DataType } from "./data-type";
 export declare function schemaToDataType(dataType: {
     [name: string]: DataTypeSchema;
 }): OrderedRecord<DataType>;
@@ -10,32 +10,32 @@ export interface DataTypeSchemaBase {
     required?: boolean;
 }
 export interface DataTypeSchemaString extends DataTypeSchemaBase {
-    type: 'string';
+    type: "string";
 }
 export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
-    type: 'number';
+    type: "number";
 }
 export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
-    type: 'boolean';
+    type: "boolean";
 }
 export interface DataTypeSchemaObject extends DataTypeSchemaBase {
-    type: 'object';
+    type: "object";
     properties?: {
         [key: string]: DataTypeSchema;
     };
 }
 export interface DataTypeSchemaArray extends DataTypeSchemaBase {
-    type: 'array';
+    type: "array";
     items?: DataTypeSchema;
 }
 type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T['properties']]: SchemaType<NonNullable<T['properties']>[K]>;
-}> : T extends DataTypeSchemaArray ? T['items'] extends null | undefined ? SchemaType<{
-    type: 'object';
-}>[] : SchemaType<NonNullable<T['items']>>[] : never;
-export type SchemaType<T extends DataTypeSchema> = T['required'] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
+    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
+}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
+    type: "object";
+}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
+export type SchemaType<T extends DataTypeSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
 export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
-    type: 'object';
+    type: "object";
     required: true;
     properties: T;
 }>;

package/lib/types/definitions/data-type.d.ts

@@ -1,5 +1,5 @@
-import { OmitPropsFromUnion } from '../utils/omit';
-import { OrderedRecord } from '../utils/ordered-map';
+import type { OmitPropsFromUnion } from "../utils/omit";
+import type { OrderedRecord } from "../utils/ordered-map";
 export type DataType = DataTypeString | DataTypeNumber | DataTypeBoolean | DataTypeObject | DataTypeArray;
 export interface DataTypeBase {
     id: string;
@@ -8,25 +8,25 @@ export interface DataTypeBase {
     required?: boolean;
 }
 export interface DataTypeString extends DataTypeBase {
-    type: 'string';
+    type: "string";
     defaultValue?: string;
     multiline?: boolean;
 }
 export interface DataTypeNumber extends DataTypeBase {
-    type: 'number';
+    type: "number";
     defaultValue?: number;
 }
 export interface DataTypeBoolean extends DataTypeBase {
-    type: 'boolean';
+    type: "boolean";
     defaultValue?: boolean;
 }
 export interface DataTypeObject extends DataTypeBase {
-    type: 'object';
+    type: "object";
     defaultValue?: object;
     properties?: OrderedRecord<DataType>;
 }
 export interface DataTypeArray extends DataTypeBase {
-    type: 'array';
+    type: "array";
     defaultValue?: object[];
-    items?: OmitPropsFromUnion<DataType, 'id'>;
+    items?: OmitPropsFromUnion<DataType, "id">;
 }

package/lib/types/definitions/memory.d.ts

@@ -1,7 +1,7 @@
-import { Memorable } from '../memorable';
-import { RunnableInput, RunnableMemory } from '../runnable';
-import { OrderedRecord } from '../utils';
-import { DataTypeSchema } from './data-type-schema';
+import type { Memorable } from "../memorable";
+import type { RunnableInput, RunnableMemory } from "../runnable";
+import { OrderedRecord } from "../utils";
+import type { DataTypeSchema } from "./data-type-schema";
 export interface CreateRunnableMemory<I extends {
     [key: string]: DataTypeSchema;
 } = {}> {
@@ -22,7 +22,7 @@ export interface CreateRunnableMemory<I extends {
          * Variable name from input used to query memory.
          */
         fromVariable?: keyof {
-            [key in keyof I as I[key]['type'] extends 'string' ? key : never]: any;
+            [key in keyof I as I[key]["type"] extends "string" ? key : never]: any;
         };
     };
     /**

package/lib/types/definitions/open-api.d.ts

@@ -1,24 +1,24 @@
-import type { DataType } from './data-type';
-import type { DataTypeSchema } from './data-type-schema';
+import type { DataType } from "./data-type";
+import type { DataTypeSchema } from "./data-type-schema";
 export interface BaseAuthConfig {
-    type: 'bearer' | 'basic';
+    type: "bearer" | "basic";
     token: string;
-    in?: 'header' | 'query' | 'cookie';
+    in?: "header" | "query" | "cookie";
     /**
      * The key to use for the token. Default `Authorization` in header and `token` in query and cookie.
      */
     key?: string;
 }
 export interface CustomAuthConfig {
-    type: 'custom';
+    type: "custom";
     getValue: () => Promise<AuthResult> | AuthResult;
 }
 export type AuthConfig = BaseAuthConfig | CustomAuthConfig;
-export type AuthType = AuthConfig['type'];
-export type AuthResult = Pick<FetchRequest, 'headers' | 'query' | 'cookies'>;
-type HTTPMethodLowercase = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+export type AuthType = AuthConfig["type"];
+export type AuthResult = Pick<FetchRequest, "headers" | "query" | "cookies">;
+type HTTPMethodLowercase = "get" | "post" | "put" | "delete" | "patch" | "head" | "options";
 export type HTTPMethod = Uppercase<HTTPMethodLowercase> | Lowercase<HTTPMethodLowercase>;
-export type ParameterLocation = 'path' | 'query' | 'body' | 'header' | 'cookie';
+export type ParameterLocation = "path" | "query" | "body" | "header" | "cookie";
 export type OpenAPIDataType = DataType & {
     in?: ParameterLocation;
 };

package/lib/types/function-agent.d.ts

@@ -1,10 +1,10 @@
-import { Agent, AgentProcessOptions } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { FunctionRunner } from './function-runner';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition } from './runnable';
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { FunctionRunner } from "./function-runner";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
 export declare class FunctionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -40,10 +40,10 @@ export declare function create<I extends {
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
 }, State extends ContextState>({ context, ...options }: CreateFunctionAgentOptions<I, O, Memories, State>): FunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export interface FunctionAgentDefinition extends RunnableDefinition {
-    type: 'function_agent';
+    type: "function_agent";
     language?: string;
     code?: string;
 }

package/lib/types/function-runner.d.ts

@@ -1,6 +1,6 @@
-import { Agent } from './agent';
-import { Context, ContextState } from './context';
-import { MemoryItemWithScore } from './memorable';
+import { Agent } from "./agent";
+import type { Context, ContextState } from "./context";
+import type { MemoryItemWithScore } from "./memorable";
 export interface FunctionRunnerInput<I extends {
     [name: string]: any;
 } = {}, Memories extends {
@@ -11,7 +11,7 @@ export interface FunctionRunnerInput<I extends {
     code: string;
     input: I;
     memories: Memories;
-    context: Pick<Context<State>, 'state'>;
+    context: Pick<Context<State>, "state">;
 }
 export type FunctionRunnerOutput<O> = O;
 export declare abstract class FunctionRunner<I extends {

package/lib/types/index.d.ts

@@ -1,18 +1,18 @@
-export * from './utils';
-export * from './constants';
-export * from './definitions/data-type';
-export * from './definitions/data-type-schema';
-export * from './definitions/open-api';
-export * from './definitions/memory';
-export * from './context';
-export * from './runnable';
-export * from './agent';
-export * from './pipeline-agent';
-export * from './llm-agent';
-export * from './llm-model';
-export * from './function-agent';
-export * from './function-runner';
-export * from './llm-decision-agent';
-export * from './local-function-agent';
-export * from './open-api-agent';
-export * from './memorable';
+export * from "./utils";
+export * from "./constants";
+export * from "./definitions/data-type";
+export * from "./definitions/data-type-schema";
+export * from "./definitions/open-api";
+export * from "./definitions/memory";
+export * from "./context";
+export * from "./runnable";
+export * from "./agent";
+export * from "./pipeline-agent";
+export * from "./llm-agent";
+export * from "./llm-model";
+export * from "./function-agent";
+export * from "./function-runner";
+export * from "./llm-decision-agent";
+export * from "./local-function-agent";
+export * from "./open-api-agent";
+export * from "./memorable";

package/lib/types/llm-agent.d.ts

@@ -1,11 +1,11 @@
-import { Agent, AgentProcessOptions } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { LLMModel, LLMModelInputMessage, LLMModelInputs } from './llm-model';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition } from './runnable';
-import { OrderedRecord } from './utils/ordered-map';
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import { OrderedRecord } from "./utils/ordered-map";
 export declare class LLMAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -28,12 +28,12 @@ export declare class LLMAgent<I extends {
     private runWithTextOutput;
 }
 export interface LLMAgentDefinition extends RunnableDefinition {
-    type: 'llm_agent';
+    type: "llm_agent";
     primaryMemoryId?: string;
     messages?: OrderedRecord<LLMModelInputMessage & {
         id: string;
     }>;
-    modelOptions?: LLMModelInputs['modelOptions'];
+    modelOptions?: LLMModelInputs["modelOptions"];
 }
 /**
  * Options to create LLMAgent.
@@ -65,7 +65,7 @@ export interface CreateLLMAgentOptions<I extends {
     /**
      * Options for LLM chat model.
      */
-    modelOptions?: LLMModelInputs['modelOptions'];
+    modelOptions?: LLMModelInputs["modelOptions"];
     /**
      * Messages to be passed to LLM chat model.
      */
@@ -91,6 +91,6 @@ declare function create<I extends {
         primary?: boolean;
     };
 }, State extends ContextState>({ context, ...options }: CreateLLMAgentOptions<I, O, Memories, State>): LLMAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export {};