@aigne/core 1.0.2-beta.4 → 1.0.2-beta.5

package/lib/dts/agent.d.ts

@@ -0,0 +1,41 @@
+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[];
+}> {
+    memories: Memories;
+}
+export declare abstract class Agent<I extends {
+    [key: string]: any;
+} = {}, O extends {
+    [key: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Runnable<I, O, State> {
+    private getMemoryQuery;
+    /**
+     * Load memories that are defined in the agent definition.
+     * @param input The agent input.
+     * @param context The AIGNE context.
+     * @returns A dictionary of memories, where the key is the memory id or name and the value is an array of memory items.
+     */
+    protected loadMemories(input: I, context?: Context): Promise<Memories>;
+    /**
+     * Update memories by user messages and assistant responses.
+     * @param messages Messages to be added to memories.
+     */
+    protected updateMemories(messages: MemoryMessage[]): Promise<void>;
+    run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+    /**
+     * Hook that is called before the agent result is returned.
+     * @param _result The agent result.
+     */
+    protected onResult(_result: O): Promise<void>;
+    abstract process(input: I, options: AgentProcessOptions<Memories>): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
+}

package/lib/dts/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const TYPES: {
+    context: symbol;
+    definition: symbol;
+    llmModel: symbol;
+    functionRunner: symbol;
+};
+export declare const StreamTextOutputName = "$text";

package/lib/dts/context.d.ts

@@ -0,0 +1,17 @@
+import type { LLMModelConfiguration } from "./llm-model";
+import type { Runnable, RunnableDefinition } from "./runnable";
+export interface ContextState {
+    userId?: string;
+    sessionId?: string;
+    [key: string]: any;
+}
+export interface ContextConfig {
+    llmModel?: LLMModelConfiguration;
+}
+export interface Context<State extends ContextState = ContextState, Config extends ContextConfig = ContextConfig> {
+    state: State;
+    config: Config;
+    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
+    register<R extends Array<RunnableDefinition | Runnable> = []>(...definition: R): void;
+    resolveDependency<T>(token: string | symbol): T;
+}

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

@@ -0,0 +1,42 @@
+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>;
+export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
+export interface DataTypeSchemaBase {
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeSchemaString extends DataTypeSchemaBase {
+    type: "string";
+}
+export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
+    type: "number";
+}
+export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
+    type: "boolean";
+}
+export interface DataTypeSchemaObject extends DataTypeSchemaBase {
+    type: "object";
+    properties?: {
+        [key: string]: DataTypeSchema;
+    };
+}
+export interface DataTypeSchemaArray extends DataTypeSchemaBase {
+    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;
+export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
+    type: "object";
+    required: true;
+    properties: T;
+}>;
+export {};

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

@@ -0,0 +1,32 @@
+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;
+    name?: string;
+    description?: string;
+    required?: boolean;
+}
+export interface DataTypeString extends DataTypeBase {
+    type: "string";
+    defaultValue?: string;
+    multiline?: boolean;
+}
+export interface DataTypeNumber extends DataTypeBase {
+    type: "number";
+    defaultValue?: number;
+}
+export interface DataTypeBoolean extends DataTypeBase {
+    type: "boolean";
+    defaultValue?: boolean;
+}
+export interface DataTypeObject extends DataTypeBase {
+    type: "object";
+    defaultValue?: object;
+    properties?: OrderedRecord<DataType>;
+}
+export interface DataTypeArray extends DataTypeBase {
+    type: "array";
+    defaultValue?: object[];
+    items?: OmitPropsFromUnion<DataType, "id">;
+}

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

@@ -0,0 +1,40 @@
+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;
+} = {}> {
+    /**
+     * Memory instance to query/store memory.
+     */
+    memory: Memorable<any>;
+    /**
+     * Custom query to retrieve memory, if not provided, all input variables will be used.
+     *
+     * @example
+     * {
+     *   fromVariable: 'question' // question is a string input variable
+     * }
+     */
+    query?: {
+        /**
+         * Variable name from input used to query memory.
+         */
+        fromVariable?: keyof {
+            [key in keyof I as I[key]["type"] extends "string" ? key : never]: any;
+        };
+    };
+    /**
+     * Custom options for memory query.
+     */
+    options?: {
+        /**
+         * Number of memories to retrieve.
+         */
+        k?: number;
+    };
+}
+export declare function toRunnableMemories<I extends {}>(agentName: string, inputs: OrderedRecord<RunnableInput>, memories: {
+    [name: string]: CreateRunnableMemory<I>;
+}): OrderedRecord<RunnableMemory>;

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

@@ -0,0 +1,36 @@
+import type { DataType } from "./data-type";
+import type { DataTypeSchema } from "./data-type-schema";
+export interface BaseAuthConfig {
+    type: "bearer" | "basic";
+    token: string;
+    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";
+    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 HTTPMethod = Uppercase<HTTPMethodLowercase> | Lowercase<HTTPMethodLowercase>;
+export type ParameterLocation = "path" | "query" | "body" | "header" | "cookie";
+export type OpenAPIDataType = DataType & {
+    in?: ParameterLocation;
+};
+export type OpenAPIDataTypeSchema = DataTypeSchema & {
+    in?: ParameterLocation;
+};
+export type FetchRequest = {
+    url: string;
+    method: HTTPMethod;
+    query?: Record<string, string | number | boolean>;
+    headers?: Record<string, string>;
+    cookies?: Record<string, string>;
+    body?: Record<string, any>;
+};
+export {};

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

@@ -0,0 +1,49 @@
+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 {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: FunctionAgentDefinition;
+    runner?: FunctionRunner<I, O, Memories, State> | undefined;
+    static create: typeof create;
+    constructor(definition: FunctionAgentDefinition, context?: Context<State>, runner?: FunctionRunner<I, O, Memories, State> | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
+}
+export interface CreateFunctionAgentOptions<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    language?: string;
+    code: string;
+}
+export declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, 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"]>;
+}, State>;
+export interface FunctionAgentDefinition extends RunnableDefinition {
+    type: "function_agent";
+    language?: string;
+    code?: string;
+}

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

@@ -0,0 +1,25 @@
+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 {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> {
+    name: string;
+    language?: string;
+    code: string;
+    input: I;
+    memories: Memories;
+    context: Pick<Context<State>, "state">;
+}
+export type FunctionRunnerOutput<O> = O;
+export declare abstract class FunctionRunner<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<FunctionRunnerInput<I, Memories, State>, FunctionRunnerOutput<O>> {
+    constructor(context?: Context);
+}

package/lib/dts/index.d.ts

@@ -0,0 +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";

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

@@ -0,0 +1,96 @@
+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 {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: LLMAgentDefinition;
+    model?: LLMModel | undefined;
+    static create: typeof create;
+    constructor(definition: LLMAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): AsyncGenerator<{
+        $text: string | undefined;
+        delta?: undefined;
+    } | {
+        delta: any;
+        $text?: undefined;
+    }, void, unknown>;
+    private runWithStructuredOutput;
+    private runWithTextOutput;
+}
+export interface LLMAgentDefinition extends RunnableDefinition {
+    type: "llm_agent";
+    primaryMemoryId?: string;
+    messages?: OrderedRecord<LLMModelInputMessage & {
+        id: string;
+    }>;
+    modelOptions?: LLMModelInputs["modelOptions"];
+}
+/**
+ * Options to create LLMAgent.
+ */
+export interface CreateLLMAgentOptions<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    /**
+     * Agent name, used to identify the agent.
+     */
+    name?: string;
+    /**
+     * Input variables for this agent.
+     */
+    inputs: I;
+    /**
+     * Output variables for this agent.
+     */
+    outputs: O;
+    /**
+     * Memories to be used in this agent.
+     */
+    memories?: Memories;
+    /**
+     * Options for LLM chat model.
+     */
+    modelOptions?: LLMModelInputs["modelOptions"];
+    /**
+     * Messages to be passed to LLM chat model.
+     */
+    messages?: LLMModelInputMessage[];
+}
+/**
+ * Create LLMAgent definition.
+ * @param options Options to create LLMAgent.
+ * @returns LLMAgent definition.
+ */
+declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I> & {
+        /**
+         * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
+         * otherwise, it will be placed in a system message.
+         *
+         * Only one primary memory is allowed.
+         */
+        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"]>;
+}, State>;
+export {};

package/lib/dts/llm-decision-agent.d.ts

@@ -0,0 +1,73 @@
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import type { DataTypeSchema } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { CreateLLMAgentOptions, LLMAgentDefinition } from "./llm-agent";
+import type { LLMModel } from "./llm-model";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition } from "./runnable";
+import { OrderedRecord } from "./utils";
+import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
+import type { UnionToIntersection } from "./utils/union";
+export declare class LLMDecisionAgent<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: LLMDecisionAgentDefinition;
+    model?: LLMModel | undefined;
+    static create: typeof create;
+    constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponse<O>>;
+}
+export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
+    description?: string;
+    runnable: R;
+}
+/**
+ * Options to create LLMDecisionAgent.
+ */
+export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> extends Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> {
+    context: Context<State>;
+    cases: {
+        [name: string]: Case;
+    };
+}
+declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
+    [name: string]: DataTypeSchema;
+}>, Memories extends {
+    [name: string]: CreateRunnableMemory<I> & {
+        /**
+         * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
+         * otherwise, it will be placed in a system message.
+         *
+         * Only one primary memory is allowed.
+         */
+        primary?: boolean;
+    };
+}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, ExtractRunnableOutputType<Case["runnable"]>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
+    type: "llm_decision_agent";
+    cases?: OrderedRecord<LLMDecisionCase>;
+}
+export interface LLMDecisionCase {
+    id: string;
+    name?: string;
+    description?: string;
+    runnable?: {
+        id?: string;
+    };
+}
+export {};

package/lib/dts/llm-model.d.ts

@@ -0,0 +1,80 @@
+import { Agent } from "./agent";
+import type { Context } from "./context";
+export type Role = "system" | "user" | "assistant" | "tool";
+export interface LLMModelInputs {
+    messages: LLMModelInputMessage[];
+    responseFormat?: {
+        type: "text";
+    } | {
+        type: "json_schema";
+        jsonSchema: {
+            name: string;
+            description?: string;
+            schema: object;
+            strict?: boolean;
+        };
+    };
+    tools?: LLMModelInputTool[];
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+            description?: string;
+        };
+    };
+    modelOptions?: LLMModelOptions;
+}
+export interface LLMModelInputMessage {
+    role: Role;
+    content: string | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_url";
+        imageUrl: {
+            url: string;
+        };
+    })[];
+    toolCalls?: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+    toolCallId?: string;
+}
+export interface LLMModelInputTool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: object;
+    };
+}
+export interface LLMModelOptions {
+    model?: string;
+    temperature?: number;
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface LLMModelOutputs {
+    $text?: string | null;
+    toolCalls?: {
+        id?: string;
+        type?: "function";
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }[];
+}
+export declare abstract class LLMModel extends Agent<LLMModelInputs, LLMModelOutputs> {
+    constructor(context?: Context);
+}
+export interface LLMModelConfiguration {
+    default?: Partial<LLMModelOptions>;
+    override?: Partial<LLMModelOptions>;
+}

package/lib/dts/local-function-agent.d.ts

@@ -0,0 +1,64 @@
+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 { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from "./runnable";
+export declare class LocalFunctionAgent<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: LocalFunctionAgentDefinition<I, O, Memories, State>;
+    static create: typeof create;
+    constructor(definition: LocalFunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
+}
+export interface LocalFunctionAgentDefinition<I extends {
+    [name: string]: any;
+}, O extends {
+    [name: string]: any;
+}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}, State extends ContextState> extends RunnableDefinition {
+    type: "local_function_agent";
+    function?: LocalFunctionFuncType<I, O, Memories, State>;
+}
+export type LocalFunctionFuncType<I extends {
+    [name: string]: any;
+}, O extends {
+    [name: string]: any;
+}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+}, State extends ContextState> = (input: I, options: {
+    memories: Memories;
+    context: Context<State>;
+}) => Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
+export interface CreateLocalFunctionAgentOptions<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    function?: LocalFunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
+        [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
+    }, State>;
+}
+declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState>({ context, ...options }: CreateLocalFunctionAgentOptions<I, O, Memories, State>): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export {};

package/lib/dts/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: Console;
+export default logger;

package/lib/dts/memorable.d.ts

@@ -0,0 +1,183 @@
+import type { LLMModelInputMessage } from "./llm-model";
+import { Runnable } from "./runnable";
+export interface MemoryMetadata {
+    [key: string]: any;
+}
+export type MemoryActionItem<T> = {
+    event: "add";
+    id: string;
+    memory: T;
+    metadata?: MemoryMetadata;
+} | {
+    event: "update";
+    id: string;
+    memory: T;
+    oldMemory: T;
+    metadata?: MemoryMetadata;
+} | {
+    event: "delete";
+    id: string;
+    memory: T;
+} | {
+    event: "none";
+    memory: T;
+};
+export interface MemoryItem<T> {
+    id: string;
+    userId?: string;
+    sessionId?: string;
+    createdAt: string;
+    updatedAt: string;
+    memory: T;
+    metadata: MemoryMetadata;
+}
+export interface MemoryItemWithScore<T = any> extends MemoryItem<T> {
+    score: number;
+}
+export type MemoryMessage = LLMModelInputMessage;
+export type MemoryActions<T> = {
+    action: "add";
+    inputs: {
+        messages: MemoryMessage[];
+        options?: {
+            userId?: string;
+            sessionId?: string;
+            metadata?: MemoryMetadata;
+        };
+    };
+    outputs: {
+        results: MemoryActionItem<T>[];
+    };
+} | {
+    action: "search";
+    inputs: {
+        query: string;
+        options?: {
+            k?: number;
+            userId?: string;
+            sessionId?: string;
+            filter?: MemoryMetadata;
+            sort?: MemorySortOptions;
+        };
+    };
+    outputs: {
+        results: MemoryItemWithScore<T>[];
+    };
+} | {
+    action: "filter";
+    inputs: {
+        options?: {
+            k?: number;
+            userId?: string;
+            sessionId?: string;
+            filter?: MemoryMetadata;
+            sort?: MemorySortOptions;
+        };
+    };
+    outputs: {
+        results: MemoryItem<T>[];
+    };
+} | {
+    action: "get";
+    inputs: {
+        memoryId: string;
+    };
+    outputs: {
+        result: MemoryItem<T> | null;
+    };
+} | {
+    action: "create";
+    inputs: {
+        memory: T;
+        options?: {
+            userId?: string;
+            sessionId?: string;
+            metadata?: MemoryMetadata;
+        };
+    };
+    outputs: {
+        result: MemoryItem<T>;
+    };
+} | {
+    action: "update";
+    inputs: {
+        memoryId: string;
+        memory: T;
+    };
+    outputs: {
+        result: MemoryItem<T> | null;
+    };
+} | {
+    action: "delete";
+    inputs: {
+        filter: string | string[] | Record<string, any>;
+    };
+    outputs: {};
+} | {
+    action: "reset";
+    inputs: {};
+    outputs: {};
+};
+export interface SortItem {
+    field: string;
+    direction: "asc" | "desc";
+}
+export type MemorySortOptions = SortItem | SortItem[];
+export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
+    constructor();
+    abstract runner?: MemoryRunner<T, C>;
+    abstract add(messages: Extract<MemoryActions<T>, {
+        action: "add";
+    }>["inputs"]["messages"], options?: Extract<MemoryActions<T>, {
+        action: "add";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "add";
+    }>["outputs"]>;
+    abstract search(query: Extract<MemoryActions<T>, {
+        action: "search";
+    }>["inputs"]["query"], options?: Extract<MemoryActions<T>, {
+        action: "search";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "search";
+    }>["outputs"]>;
+    abstract filter(options: Extract<MemoryActions<T>, {
+        action: "filter";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "filter";
+    }>["outputs"]>;
+    abstract get(memoryId: Extract<MemoryActions<T>, {
+        action: "get";
+    }>["inputs"]["memoryId"]): Promise<Extract<MemoryActions<T>, {
+        action: "get";
+    }>["outputs"]>;
+    abstract create(memory: Extract<MemoryActions<T>, {
+        action: "create";
+    }>["inputs"]["memory"], options?: Extract<MemoryActions<T>, {
+        action: "create";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "create";
+    }>["outputs"]>;
+    abstract update(memoryId: Extract<MemoryActions<T>, {
+        action: "update";
+    }>["inputs"]["memoryId"], memory: T): Promise<Extract<MemoryActions<T>, {
+        action: "update";
+    }>["outputs"]>;
+    abstract delete(memoryId: Extract<MemoryActions<T>, {
+        action: "delete";
+    }>["inputs"]["filter"]): Promise<Extract<MemoryActions<T>, {
+        action: "delete";
+    }>["outputs"]>;
+    abstract reset(): Promise<void>;
+}
+export interface MemoryRunnerInput<C = undefined> {
+    messages: MemoryMessage[];
+    userId?: string;
+    sessionId?: string;
+    metadata?: MemoryMetadata;
+    filter?: MemoryMetadata;
+    customData: C;
+}
+export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryActionItem<T>[]> {
+    constructor(name: string);
+}
+export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/dts/open-api-agent.d.ts

@@ -0,0 +1,55 @@
+import { Agent } 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 { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from "./definitions/open-api";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import type { OrderedRecord } from "./utils";
+export declare class OpenAPIAgent<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: OpenAPIAgentDefinition;
+    static create: typeof create;
+    constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
+    process(input: I): Promise<O>;
+    fetch<T>(request: FetchRequest): Promise<T>;
+}
+export interface OpenAPIAgentDefinition extends RunnableDefinition {
+    type: "open_api_agent";
+    inputs: OrderedRecord<OpenAPIDataType>;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+export interface CreateOpenAPIAgentOptions<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState> {
+    context?: Context<State>;
+    id?: string;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    url: string;
+    method?: HTTPMethod;
+    auth?: AuthConfig;
+}
+declare function create<I extends {
+    [name: string]: OpenAPIDataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema;
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export {};

package/lib/dts/pipeline-agent.d.ts

@@ -0,0 +1,79 @@
+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 { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from "./runnable";
+import type { MakeNullablePropertyOptional } from "./utils/nullable";
+import { OrderedRecord } from "./utils/ordered-map";
+import type { ExtractRunnableInputType } from "./utils/runnable-type";
+export declare class PipelineAgent<I extends {
+    [key: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, Memories extends {
+    [name: string]: MemoryItemWithScore[];
+} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+    definition: PipelineAgentDefinition;
+    static create: typeof create;
+    constructor(definition: PipelineAgentDefinition, context?: Context<State>);
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
+}
+type VariableWithPropPath = {
+    fromVariable: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcessParameter<R extends Runnable = any, RI extends {
+    [name: string]: DataTypeSchema;
+} = ExtractRunnableInputType<R>> = {
+    runnable: R;
+    input: MakeNullablePropertyOptional<{
+        [key in keyof RI]: VariableWithPropPath;
+    }>;
+};
+declare function create<I extends {
+    [name: string]: DataTypeSchema;
+}, O extends {
+    [name: string]: DataTypeSchema & {
+        fromVariable: string;
+        fromVariablePropPath?: string[];
+    };
+}, Memories extends {
+    [name: string]: CreateRunnableMemory<I>;
+}, State extends ContextState, Processes extends {
+    [name: string]: PipelineAgentProcessParameter;
+}>({ context, ...options }: {
+    context: Context<State>;
+    name?: string;
+    inputs: I;
+    outputs: O;
+    memories?: Memories;
+    processes: Processes;
+}): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
+}, State>;
+export interface PipelineAgentDefinition extends RunnableDefinition {
+    type: "pipeline_agent";
+    processes?: OrderedRecord<PipelineAgentProcess>;
+    outputs: OrderedRecord<PipelineAgentOutput>;
+}
+export type PipelineAgentOutput = RunnableOutput & {
+    from: "variable";
+    fromVariableId?: string;
+    fromVariablePropPath?: (string | number)[];
+};
+export type PipelineAgentProcess = {
+    id: string;
+    name?: string;
+    runnable?: {
+        id?: string;
+    };
+    input?: {
+        [inputId: string]: {
+            from: "variable";
+            fromVariableId?: string;
+            fromVariablePropPath?: (string | number | symbol)[];
+        };
+    };
+};
+export {};

package/lib/dts/runnable.d.ts

@@ -0,0 +1,70 @@
+import type { Context, ContextState } from "./context";
+import type { DataType } from "./definitions/data-type";
+import type { Memorable } from "./memorable";
+import { OrderedRecord } from "./utils/ordered-map";
+export interface RunOptions {
+    stream?: boolean;
+}
+export type RunnableResponse<T> = T | RunnableResponseStream<T>;
+export declare abstract class Runnable<I extends {
+    [name: string]: any;
+} = {}, O extends {
+    [name: string]: any;
+} = {}, State extends ContextState = ContextState> {
+    definition: RunnableDefinition;
+    context?: Context<State> | undefined;
+    constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
+    get id(): string;
+    get name(): string | undefined;
+    inputs: {
+        [key in keyof I]: DataType;
+    };
+    outputs: {
+        [key in keyof O]: DataType;
+    };
+    abstract run(input: I, options: RunOptions & {
+        stream: true;
+    }): Promise<RunnableResponseStream<O>>;
+    abstract run(input: I, options?: RunOptions & {
+        stream?: false;
+    }): Promise<O>;
+    abstract run(input: I, options?: RunOptions): Promise<RunnableResponse<O>>;
+}
+export interface RunnableDefinition {
+    id: string;
+    type: string;
+    name?: string;
+    description?: string;
+    memories?: OrderedRecord<RunnableMemory>;
+    inputs: OrderedRecord<RunnableInput>;
+    outputs: OrderedRecord<RunnableOutput>;
+}
+export interface RunnableMemory {
+    id: string;
+    name?: string;
+    memory?: Memorable<any>;
+    query?: {
+        from: "variable";
+        fromVariableId?: string;
+        fromVariablePropPath?: string[];
+    };
+    options?: {
+        k?: number;
+    };
+}
+export type RunnableInput = DataType;
+export type RunnableOutput = DataType;
+export interface RunnableResponseDelta<T> {
+    $text?: string;
+    delta?: Partial<T>;
+}
+export interface RunnableResponseError {
+    error: {
+        message: string;
+    };
+}
+export type RunnableResponseChunk<T> = RunnableResponseDelta<T>;
+export type RunnableResponseChunkWithError<T> = RunnableResponseChunk<T> | RunnableResponseError;
+export declare function isRunnableResponseDelta<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseDelta<T>;
+export declare function isRunnableResponseError<T>(chunk: RunnableResponseChunkWithError<T>): chunk is RunnableResponseError;
+export type RunnableResponseStream<T> = ReadableStream<RunnableResponseChunk<T>>;

package/lib/dts/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const FETCH_TIMEOUT: number;

package/lib/dts/utils/fetch-open-api.d.ts

@@ -0,0 +1,2 @@
+import type { FetchRequest } from "../definitions/open-api";
+export declare function fetchOpenApi<T>(request: FetchRequest): Promise<T>;

package/lib/dts/utils/fetch.d.ts

@@ -0,0 +1 @@
+export declare function checkFetchResponse(result: Response): Promise<Response>;

package/lib/dts/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./fetch";
+export * from "./fetch-open-api";
+export * from "./is-non-nullable";
+export * from "./mustache-utils";
+export * from "./nullable";
+export * from "./omit";
+export * from "./open-api-parameter";
+export * from "./ordered-map";
+export * from "./stream-utils";
+export * from "./union";

package/lib/dts/utils/is-non-nullable.d.ts

@@ -0,0 +1,2 @@
+export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+export declare function isPropsNonNullable<T, K extends keyof T>(...props: (K | K[])[]): (value: T) => value is T & Required<Pick<T, K>>;

package/lib/dts/utils/message-utils.d.ts

@@ -0,0 +1,20 @@
+import type { LLMAgentDefinition } from "../llm-agent";
+import type { LLMModelInputMessage } from "../llm-model";
+import type { MemoryItemWithScore } from "../memorable";
+export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
+export declare function memoriesToMessages(memories: {
+    [name: string]: MemoryItemWithScore[];
+}, { primaryMemoryName }?: {
+    primaryMemoryName?: string;
+}): {
+    primaryMemory: LLMModelInputMessage[];
+    memory: string;
+};
+export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
+    [name: string]: any;
+}, memories: {
+    [name: string]: MemoryItemWithScore[];
+}): {
+    originalMessages: LLMModelInputMessage[];
+    messagesWithMemory: LLMModelInputMessage[];
+};

package/lib/dts/utils/mustache-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function renderMessage(template: string, variables?: {
+    [key: string]: any;
+}): string;

package/lib/dts/utils/nullable.d.ts

@@ -0,0 +1,7 @@
+export type MakeNullablePropertyOptional<T extends {
+    [key: string]: any;
+}> = {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
+} & {
+    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
+};

package/lib/dts/utils/omit.d.ts

@@ -0,0 +1 @@
+export type OmitPropsFromUnion<T, K extends string | number | symbol> = T extends any ? Omit<T, K> : never;

package/lib/dts/utils/open-api-parameter.d.ts

@@ -0,0 +1,7 @@
+import type { AuthConfig, FetchRequest, HTTPMethod } from "../definitions/open-api";
+import type { OpenAPIAgentDefinition } from "../open-api-agent";
+export declare function formatOpenAPIRequest(api: {
+    url: string;
+    method: HTTPMethod;
+    auth?: AuthConfig;
+}, inputs: OpenAPIAgentDefinition["inputs"], input: Record<string, any>): Promise<FetchRequest>;

package/lib/dts/utils/ordered-map.d.ts

@@ -0,0 +1,37 @@
+export type OrderedRecord<T extends {
+    id: string;
+}> = Record<string, T> & {
+    $indexes: string[];
+};
+export declare namespace OrderedRecord {
+    function iterator<T extends {
+        id: string;
+    }>(record?: OrderedRecord<T>): IterableIterator<T>;
+    function map<O, T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, fn: (value: T, index: number) => O): O[];
+    function toArray<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined): T[];
+    function fromArray<T extends {
+        id: string;
+    }>(array?: T[]): OrderedRecord<T>;
+    function find<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T | undefined;
+    function filter<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, predicate: (value: T, index: number) => boolean): T[];
+    function at<T extends {
+        id: string;
+    }>(record: OrderedRecord<T> | undefined, index: number): T | undefined;
+    function push<T extends {
+        id: string;
+    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
+    function merge<T extends {
+        id: string;
+    }>(...records: OrderedRecord<T>[]): OrderedRecord<T>;
+    function pushOrUpdate<T extends {
+        id: string;
+    }>(record: OrderedRecord<T>, ...items: T[]): OrderedRecord<T>;
+}

package/lib/dts/utils/runnable-type.d.ts

@@ -0,0 +1,3 @@
+import type { Runnable, RunnableResponseStream } from "../runnable";
+export type ExtractRunnableInputType<T> = T extends Runnable<infer I, any> ? I : never;
+export type ExtractRunnableOutputType<T> = T extends Runnable<any, infer O> ? Exclude<O, RunnableResponseStream<any>> : never;

package/lib/dts/utils/stream-utils.d.ts

@@ -0,0 +1,20 @@
+import { type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "../runnable";
+export declare function objectToRunnableResponseStream<T extends {
+    [key: string]: any;
+}>(obj: T): RunnableResponseStream<T>;
+export declare function runnableResponseStreamToObject<T extends {
+    [key: string]: any;
+}>(stream: RunnableResponseStream<T> | AsyncGenerator<RunnableResponseChunk<T>>): Promise<T>;
+/**
+ * Extracts the outputs from a runnable output stream and run the
+ * resolve function on the result before the stream closes. It can be
+ * used to update the memories of an agent.
+ * @param output The runnable output stream or object
+ * @param resolve The function to run on the result
+ * @returns The runnable output stream or object
+ */
+export declare function extractOutputsFromRunnableOutput<T extends {
+    [key: string]: any;
+}>(output: RunnableResponse<T> | AsyncGenerator<RunnableResponseChunk<T>>, resolve: (result: T) => Promise<void> | void): Promise<RunnableResponse<T>>;
+export declare function asyncGeneratorToReadableStream<T>(generator: AsyncGenerator<T>): ReadableStream<T>;
+export declare function isAsyncGenerator<T extends AsyncGenerator>(value: any): value is T;

package/lib/dts/utils/structured-output-schema.d.ts

@@ -0,0 +1,3 @@
+import type { RunnableOutput } from "../runnable";
+import { OrderedRecord } from "./ordered-map";
+export declare function outputsToJsonSchema(outputs: OrderedRecord<RunnableOutput>): object;

package/lib/dts/utils/union.d.ts

@@ -0,0 +1 @@
+export type UnionToIntersection<U, O = any> = (U extends any ? (arg: U) => void : never) extends (arg: infer I) => void ? I extends O ? I : never : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.2-beta.4",
+  "version": "1.0.2-beta.5",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"
@@ -13,7 +13,7 @@
   "types": "./lib/dts/index.d.ts",
   "files": [
     "lib/cjs",
-    "lib/dst",
+    "lib/dts",
     "lib/esm",
     "LICENSE",
     "package.json",