@aigne/core 1.0.9 → 1.0.11

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

@@ -1,55 +1,26 @@
-import { Agent } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 SchemaToType } from "./definitions/data-schema";
+import type { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType } from "./definitions/open-api";
+import type { RunnableInput, RunnableOutput } 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> {
+export declare class OpenAPIAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
     definition: OpenAPIAgentDefinition;
     static create: typeof create;
     constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
-    process(input: I): Promise<O>;
+    process(input: AgentProcessInput<I, Preloads, Memories>): Promise<O>;
     fetch<T>(request: FetchRequest): Promise<T>;
 }
-export interface OpenAPIAgentDefinition extends RunnableDefinition {
+export interface OpenAPIAgentDefinition extends AgentDefinition {
     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;
+declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, 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>;
+}): OpenAPIAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
 export {};

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

@@ -1,63 +1,40 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 SchemaToType } from "./definitions/data-schema";
+import type { Runnable, RunnableInput, RunnableOutput, RunnableOutputType, 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> {
+export declare class PipelineAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, AgentPreloads, Memories> {
     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>>>;
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, 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>> = {
+export type PipelineAgentProcessParameter<R extends Runnable = Runnable, RI extends RunnableInput = 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 {
+declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema<{
+    fromVariable: string;
+    fromVariablePropPath?: string[];
+}>, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>, Processes extends {
     [name: string]: PipelineAgentProcessParameter;
-}>({ context, ...options }: {
-    context: Context<State>;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
+}>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
     processes: Processes;
-}): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
-export interface PipelineAgentDefinition extends RunnableDefinition {
+}): PipelineAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+export interface PipelineAgentDefinition extends AgentDefinition {
     type: "pipeline_agent";
     processes?: OrderedRecord<PipelineAgentProcess>;
     outputs: OrderedRecord<PipelineAgentOutput>;
 }
-export type PipelineAgentOutput = RunnableOutput & {
+export type PipelineAgentOutput = RunnableOutputType & {
     from: "variable";
     fromVariableId?: string;
     fromVariablePropPath?: (string | number)[];

package/lib/dts/runnable.d.ts

@@ -1,16 +1,13 @@
 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> {
+export type RunnableInput = Record<string, any>;
+export type RunnableOutput = Record<string, any>;
+export declare abstract class Runnable<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState> {
     definition: RunnableDefinition;
     context?: Context<State> | undefined;
     constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
@@ -35,25 +32,11 @@ export interface RunnableDefinition {
     type: string;
     name?: string;
     description?: string;
-    memories?: OrderedRecord<RunnableMemory>;
-    inputs: OrderedRecord<RunnableInput>;
-    outputs: OrderedRecord<RunnableOutput>;
+    inputs: OrderedRecord<RunnableInputType>;
+    outputs: OrderedRecord<RunnableOutputType>;
 }
-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 type RunnableInputType = DataType;
+export type RunnableOutputType = DataType;
 export interface RunnableResponseDelta<T> {
     $text?: string;
     delta?: Partial<T>;

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

@@ -1,48 +1,20 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 } from "./runnable";
+import { type SchemaToType } from "./definitions/data-schema";
+import type { RunnableInput, RunnableOutput } from "./runnable";
 import type { SandboxFunctionRunner } from "./sandbox-function-runner";
-export declare class SandboxFunctionAgent<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> {
+export declare class SandboxFunctionAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
     definition: SandboxFunctionAgentDefinition;
-    runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined;
+    runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined;
     static create: typeof create;
-    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined);
-    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
+    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined);
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
 }
-export interface CreateSandboxFunctionAgentOptions<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;
+export declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, 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 }: CreateSandboxFunctionAgentOptions<I, O, Memories, State>): SandboxFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
-export interface SandboxFunctionAgentDefinition extends RunnableDefinition {
+}): SandboxFunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+export interface SandboxFunctionAgentDefinition extends AgentDefinition {
     type: "sandbox_function_agent";
     language?: string;
     code?: string;

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

@@ -1,25 +1,16 @@
-import { Agent } from "./agent";
+import { Agent, type AgentMemories, type AgentPreloads } from "./agent";
 import type { Context, ContextState } from "./context";
-import type { MemoryItemWithScore } from "./memorable";
-export interface SandboxFunctionRunnerInput<I extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> {
+import type { RunnableInput, RunnableOutput } from "./runnable";
+export type SandboxFunctionRunnerInput<Input extends RunnableInput = RunnableInput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
     name: string;
     language?: string;
     code: string;
-    input: I;
+    input: Input;
+    preloads: Preloads;
     memories: Memories;
     context: Pick<Context<State>, "state">;
-}
-export type SandboxFunctionRunnerOutput<O> = O;
-export declare abstract class SandboxFunctionRunner<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends Agent<SandboxFunctionRunnerInput<I, Memories, State>, SandboxFunctionRunnerOutput<O>> {
+};
+export type SandboxFunctionRunnerOutput<Output extends RunnableOutput> = Output;
+export declare abstract class SandboxFunctionRunner<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<SandboxFunctionRunnerInput<I, State, Preloads, Memories>, SandboxFunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

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

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./fetch-open-api";
 export * from "./is-non-nullable";
+export * from "./logger";
 export * from "./mustache-utils";
 export * from "./nullable";
 export * from "./omit";

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

@@ -0,0 +1,3 @@
+type Logger = Pick<typeof console, "debug" | "info" | "warn" | "error">;
+export declare const logger: Logger;
+export {};

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

@@ -11,7 +11,7 @@ export declare function memoriesToMessages(memories: {
     memory: string;
 };
 export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
-    [name: string]: any;
+    [name: string]: unknown;
 }, memories: {
     [name: string]: MemoryItemWithScore[];
 }): {

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

@@ -1,3 +1,5 @@
-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;
+import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
+import type { UnionToIntersection } from "./union";
+export type ExtractRunnableInputType<T> = T extends Runnable<infer I, RunnableOutput> ? I : never;
+export type ExtractRunnableOutputType<T> = T extends Runnable<RunnableInput, infer O> ? Exclude<O, RunnableResponseStream<unknown>> : never;
+export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, Record<string, unknown>>;

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

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

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

@@ -0,0 +1 @@
+export type ArrayElement<T> = T extends (infer U)[] ? U : never;

package/lib/esm/agent.d.ts

@@ -1,18 +1,17 @@
 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> {
+import type { DataSchema } from "./definitions/data-schema";
+import type { AgentMemory, CreateRunnableMemory } from "./definitions/memory";
+import type { AgentPreload, BindAgentInputs, BoundAgent, PreloadCreator } from "./definitions/preload";
+import type { MemorableSearchOutput, MemoryItemWithScore, MemoryMessage } from "./memorable";
+import { type RunOptions, Runnable, type RunnableDefinition, type RunnableInput, type RunnableOutput, type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "./runnable";
+import { OrderedRecord } from "./utils";
+import type { ExtractRunnableOutputType } from "./utils/runnable-type";
+export type AgentPreloads = Record<string, unknown>;
+export type AgentMemories = Record<string, MemoryItemWithScore[]>;
+export declare abstract class Agent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Runnable<I, O, State> {
+    definition: AgentDefinition;
+    context?: Context<State> | undefined;
+    constructor(definition: AgentDefinition, context?: Context<State> | undefined);
     private getMemoryQuery;
     /**
      * Load memories that are defined in the agent definition.
@@ -20,12 +19,13 @@ export declare abstract class Agent<I extends {
      * @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>;
+    protected loadMemories(input: I): Promise<Memories>;
     /**
      * Update memories by user messages and assistant responses.
      * @param messages Messages to be added to memories.
      */
     protected updateMemories(messages: MemoryMessage[]): Promise<void>;
+    protected loadPreloads(input: I): Promise<Preloads>;
     run(input: I, options: RunOptions & {
         stream: true;
     }): Promise<RunnableResponseStream<O>>;
@@ -37,5 +37,59 @@ export declare abstract class Agent<I extends {
      * @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>;
+    abstract process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
+    /**
+     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
+     * @param options The bind options.
+     * @returns The bound agent.
+     */
+    bind<Input extends BindAgentInputs<Record<string, never>, typeof this>>(options: {
+        description?: string;
+        input?: Input;
+    }): BoundAgent<Record<string, never>, typeof this, Readonly<Input>>;
+}
+export type AgentProcessOptions<Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
+    preloads: Preloads;
+    memories: Memories;
+};
+export type AgentProcessInput<I extends RunnableInput, Preloads extends AgentPreloads, Memories extends AgentMemories> = I & Preloads & Memories;
+export interface AgentDefinition extends RunnableDefinition {
+    preloads?: OrderedRecord<AgentPreload>;
+    memories?: OrderedRecord<AgentMemory>;
+}
+export type CreateAgentInputSchema = Record<string, DataSchema>;
+export type CreateAgentOutputSchema<Extra extends Record<string, unknown> = Record<string, unknown>> = Record<string, DataSchema & Extra>;
+export type CreateAgentPreloadsSchema<I extends CreateAgentInputSchema> = Record<string, PreloadCreator<I>>;
+export type CreateAgentPreloadsType<I extends CreateAgentInputSchema, Preloads extends CreateAgentPreloadsSchema<I>> = {
+    [name in keyof Preloads]: ExtractRunnableOutputType<ReturnType<Preloads[name]>["runnable"]>;
+};
+export type CreateAgentMemoriesSchema<I extends CreateAgentInputSchema, Extras extends Record<string, unknown> = Record<string, unknown>> = Record<string, CreateRunnableMemory<I> & Extras>;
+export type CreateAgentMemoriesType<I extends CreateAgentInputSchema, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> = {
+    [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
+};
+/**
+ * Common options to create Agent.
+ */
+export interface CreateAgentOptions<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I, Record<string, unknown>>> {
+    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;
+    /**
+     * Preload runnables before running this agent. the preloaded data are available in the agent as input variables.
+     */
+    preloads?: Preloads;
+    /**
+     * Memories to be used in this agent.
+     */
+    memories?: Memories;
 }

package/lib/esm/agent.js

@@ -1,13 +1,20 @@
-import logger from "./logger";
 import { Runnable, } from "./runnable";
 import { OrderedRecord, extractOutputsFromRunnableOutput, isAsyncGenerator, isNonNullable, objectToRunnableResponseStream, renderMessage, runnableResponseStreamToObject, } from "./utils";
+import { logger } from "./utils/logger";
 export class Agent extends Runnable {
+    definition;
+    context;
+    constructor(definition, context) {
+        super(definition, context);
+        this.definition = definition;
+        this.context = context;
+    }
     async getMemoryQuery(input, query) {
         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];
+            const value = i.name ? input[i.name] : undefined;
             return renderMessage("{{value}}", { value });
         }
         return Object.entries(input)
@@ -20,9 +27,13 @@ export class Agent extends Runnable {
      * @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.
      */
-    async loadMemories(input, context) {
-        const { memories } = this.definition;
-        const { userId, sessionId } = context?.state ?? {};
+    async loadMemories(input) {
+        const { definition: { memories }, context, } = this;
+        if (!memories?.$indexes.length)
+            return {};
+        if (!context)
+            throw new Error("Context is required");
+        const { userId, sessionId } = context.state;
         return Object.fromEntries((await Promise.all(OrderedRecord.map(memories, async ({ id, name, memory, query, options }) => {
             if (!name || !memory)
                 return null;
@@ -45,8 +56,10 @@ export class Agent extends Runnable {
      * @param messages Messages to be added to memories.
      */
     async updateMemories(messages) {
-        const { memories } = this.definition;
-        const { userId, sessionId } = this.context?.state ?? {};
+        const { context, definition: { memories }, } = this;
+        if (!context)
+            throw new Error("Context is required");
+        const { userId, sessionId } = context.state ?? {};
         await Promise.all(OrderedRecord.map(memories, async ({ memory }) => {
             if (!memory) {
                 logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
@@ -55,12 +68,43 @@ export class Agent extends Runnable {
             await memory.add(messages, { userId, sessionId });
         }));
     }
+    async loadPreloads(input) {
+        const { context, definition: { preloads }, } = this;
+        if (!preloads?.$indexes.length)
+            return {};
+        if (!context)
+            throw new Error("Context is required");
+        return Object.fromEntries(await Promise.all(OrderedRecord.map(preloads, async (preload) => {
+            if (!preload.runnable?.id)
+                throw new Error("Runnable id in preload is required");
+            const runnable = await context.resolve(preload.runnable.id);
+            const runnableInput = Object.fromEntries(OrderedRecord.map(runnable.definition.inputs, (i) => {
+                if (!i.name)
+                    return null;
+                const bind = preload.input?.[i.id];
+                if (!bind)
+                    return null;
+                if (bind.from !== "input")
+                    throw new Error(`Unsupported bind from ${bind.from}`);
+                const from = this.definition.inputs[bind.fromInput];
+                if (!from)
+                    throw new Error(`Input ${bind.fromInput} not found`);
+                if (!from.name)
+                    return null;
+                const v = input[from.name];
+                return [i.name, v];
+            }).filter(isNonNullable));
+            const result = await runnable.run(runnableInput);
+            return [preload.id, result];
+        })));
+    }
     async run(input, options) {
         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 });
+        const preloads = await this.loadPreloads(input);
+        const memories = await this.loadMemories(input);
+        const processResult = await this.process({ ...input, ...preloads, ...memories }, { preloads, memories });
         if (options?.stream) {
             const stream = processResult instanceof ReadableStream ||
                 isAsyncGenerator(processResult)
@@ -94,4 +138,15 @@ export class Agent extends Runnable {
     async onResult(_result) {
         // Override this method to perform additional operations before the result is returned
     }
+    /**
+     * Bind some inputs to the agent, used for process of `PipelineAgent` or case of `LLMDecisionAgent`.
+     * @param options The bind options.
+     * @returns The bound agent.
+     */
+    bind(options) {
+        return {
+            ...options,
+            runnable: this,
+        };
+    }
 }

package/lib/esm/context.d.ts

@@ -3,7 +3,7 @@ import type { Runnable, RunnableDefinition } from "./runnable";
 export interface ContextState {
     userId?: string;
     sessionId?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface ContextConfig {
     llmModel?: LLMModelConfiguration;

package/lib/esm/definitions/data-schema.d.ts

@@ -0,0 +1,61 @@
+import type { MakeNullablePropertyOptional } from "../utils/nullable";
+import { OrderedRecord } from "../utils/ordered-map";
+import type { ArrayElement } from "../utils/type-utils";
+import type { DataType } from "./data-type";
+export declare function schemaToDataType(dataType: {
+    [name: string]: DataSchema;
+}): OrderedRecord<DataType>;
+export type DataSchema = DataSchemaString | DataSchemaNumber | DataSchemaBoolean | DataSchemaObject | DataSchemaArray;
+export interface DataSchemaBase {
+    description?: string;
+    required?: boolean;
+}
+export interface DataSchemaString extends DataSchemaBase {
+    type: "string";
+}
+export interface DataSchemaNumber extends DataSchemaBase {
+    type: "number";
+}
+export interface DataSchemaBoolean extends DataSchemaBase {
+    type: "boolean";
+}
+export interface DataSchemaObject extends DataSchemaBase {
+    type: "object";
+    properties?: {
+        [key: string]: DataSchema;
+    };
+}
+export interface DataSchemaArray extends DataSchemaBase {
+    type: "array";
+    items?: DataSchema;
+}
+type SchemaTypeInner<T extends DataSchema> = T extends DataSchemaString ? string : T extends DataSchemaNumber ? number : T extends DataSchemaBoolean ? boolean : T extends DataSchemaObject ? MakeNullablePropertyOptional<{
+    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
+}> : T extends DataSchemaArray ? Extract<T["items"], null | undefined> extends null | undefined ? SchemaType<{
+    type: "object";
+}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
+type SchemaType<T extends DataSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
+export type SchemaToType<T extends Record<string, DataSchema>> = SchemaType<{
+    type: "object";
+    required: true;
+    properties: T;
+}>;
+type TypeToSchemaInner<T> = Extract<T, string | undefined> extends string | undefined ? DataSchemaString & {
+    required: Extract<T, undefined> extends undefined ? false : true;
+} : Extract<T, number | undefined> extends number | undefined ? DataSchemaNumber & {
+    required: Extract<T, undefined> extends undefined ? false : true;
+} : Extract<T, boolean | undefined> extends boolean | undefined ? DataSchemaBoolean & {
+    required: Extract<T, undefined> extends undefined ? false : true;
+} : Extract<T, object | undefined> extends object | undefined ? DataSchemaObject & {
+    properties: {
+        [K in keyof T]: TypeToSchemaInner<NonNullable<T[K]>>;
+    };
+    required: Extract<T, undefined> extends undefined ? false : true;
+} : Extract<T, [] | undefined> extends [] | undefined ? DataSchemaArray & {
+    items: Extract<T, undefined> extends undefined ? undefined : TypeToSchemaInner<NonNullable<ArrayElement<T>>>;
+    required: Extract<T, undefined> extends undefined ? false : true;
+} : never;
+export type TypeToSchema<T extends Record<string, unknown>> = {
+    [K in keyof T]: TypeToSchemaInner<T[K]>;
+};
+export {};