@aigne/core 1.0.10 → 1.0.11

package/lib/cjs/agent.d.ts

@@ -1,19 +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";
-import type { BindAgentInputs, BoundAgent } from "./utils/runnable-type";
-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.
@@ -21,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>>;
@@ -38,14 +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<typeof this>>(options: {
+    bind<Input extends BindAgentInputs<Record<string, never>, typeof this>>(options: {
         description?: string;
         input?: Input;
-    }): BoundAgent<typeof this, Readonly<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/cjs/agent.js

@@ -1,19 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
-const logger_1 = __importDefault(require("./logger"));
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
+const logger_1 = require("./utils/logger");
 class Agent extends runnable_1.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 = utils_1.OrderedRecord.find(this.definition.inputs, (i) => i.id === query.fromVariableId);
             if (!i)
                 throw new Error(`Input variable ${query.fromVariableId} not found`);
-            const value = input[i.name];
+            const value = i.name ? input[i.name] : undefined;
             return (0, utils_1.renderMessage)("{{value}}", { value });
         }
         return Object.entries(input)
@@ -26,9 +30,13 @@ class Agent extends runnable_1.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(utils_1.OrderedRecord.map(memories, async ({ id, name, memory, query, options }) => {
             if (!name || !memory)
                 return null;
@@ -51,22 +59,55 @@ class Agent extends runnable_1.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(utils_1.OrderedRecord.map(memories, async ({ memory }) => {
             if (!memory) {
-                logger_1.default.warn(`Memory is not defined in agent ${this.name || this.id}`);
+                logger_1.logger.warn(`Memory is not defined in agent ${this.name || this.id}`);
                 return;
             }
             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(utils_1.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(utils_1.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(utils_1.isNonNullable));
+            const result = await runnable.run(runnableInput);
+            return [preload.id, result];
+        })));
+    }
     async run(input, options) {
-        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} with`, {
+        logger_1.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 ||
                 (0, utils_1.isAsyncGenerator)(processResult)
@@ -74,7 +115,7 @@ class Agent extends runnable_1.Runnable {
                 : (0, utils_1.objectToRunnableResponseStream)(processResult);
             return (0, utils_1.extractOutputsFromRunnableOutput)(stream, async (result) => {
                 // TODO: validate result against outputs schema
-                logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
+                logger_1.logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
                     result,
                 });
                 await this.onResult(result);
@@ -85,7 +126,7 @@ class Agent extends runnable_1.Runnable {
             : Symbol.asyncIterator in processResult
                 ? await (0, utils_1.runnableResponseStreamToObject)(processResult)
                 : processResult;
-        logger_1.default.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
+        logger_1.logger.debug(`AIGNE core: run agent ${this.name || this.id} success`, {
             result,
         });
         // TODO: validate result against outputs schema

package/lib/cjs/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/cjs/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 {};

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

@@ -1,9 +1,22 @@
 import type { Memorable } from "../memorable";
-import type { RunnableInput, RunnableMemory } from "../runnable";
+import type { RunnableInputType } from "../runnable";
 import { OrderedRecord } from "../utils";
-import type { DataTypeSchema } from "./data-type-schema";
+import type { DataSchema } from "./data-schema";
+export interface AgentMemory {
+    id: string;
+    name?: string;
+    memory?: Memorable<unknown>;
+    query?: {
+        from: "variable";
+        fromVariableId?: string;
+        fromVariablePropPath?: string[];
+    };
+    options?: {
+        k?: number;
+    };
+}
 export interface CreateRunnableMemory<I extends {
-    [key: string]: DataTypeSchema;
+    [key: string]: DataSchema;
 } = {}> {
     /**
      * Memory instance to query/store memory.
@@ -35,6 +48,6 @@ export interface CreateRunnableMemory<I extends {
         k?: number;
     };
 }
-export declare function toRunnableMemories<I extends {}>(agentName: string, inputs: OrderedRecord<RunnableInput>, memories: {
+export declare function toRunnableMemories<I extends {}>(agentName: string, inputs: OrderedRecord<RunnableInputType>, memories: {
     [name: string]: CreateRunnableMemory<I>;
-}): OrderedRecord<RunnableMemory>;
+}): OrderedRecord<AgentMemory>;

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

@@ -1,5 +1,5 @@
+import type { DataSchema } from "./data-schema";
 import type { DataType } from "./data-type";
-import type { DataTypeSchema } from "./data-type-schema";
 export interface BaseAuthConfig {
     type: "bearer" | "basic";
     token: string;
@@ -22,7 +22,7 @@ export type ParameterLocation = "path" | "query" | "body" | "header" | "cookie";
 export type OpenAPIDataType = DataType & {
     in?: ParameterLocation;
 };
-export type OpenAPIDataTypeSchema = DataTypeSchema & {
+export type OpenAPIDataTypeSchema = DataSchema & {
     in?: ParameterLocation;
 };
 export type FetchRequest = {
@@ -31,6 +31,6 @@ export type FetchRequest = {
     query?: Record<string, string | number | boolean>;
     headers?: Record<string, string>;
     cookies?: Record<string, string>;
-    body?: Record<string, any>;
+    body?: Record<string, unknown>;
 };
 export {};

package/lib/cjs/definitions/preload.d.ts

@@ -0,0 +1,43 @@
+import type { CreateAgentInputSchema, CreateAgentPreloadsSchema } from "../agent";
+import type { Runnable, RunnableInputType } from "../runnable";
+import { OrderedRecord } from "../utils/ordered-map";
+import type { ExtractRunnableInputType } from "../utils/runnable-type";
+import type { UnionToIntersection } from "../utils/union";
+import type { SchemaToType } from "./data-schema";
+export declare function preloadCreatorsToPreloads<I extends CreateAgentInputSchema, C extends CreateAgentPreloadsSchema<I>>(inputs: OrderedRecord<RunnableInputType>, creators?: C): OrderedRecord<AgentPreload>;
+export type PreloadCreator<I extends CreateAgentInputSchema> = (preload: <R extends Runnable, Input extends BindAgentInputs<SchemaToType<I>, R>>(runnable: R, input: Input, options?: {
+    description?: string;
+}) => Readonly<BoundAgent<I, R, Input>>) => ReturnType<typeof preload>;
+export type BindAgentInputs<Vars extends Record<string, unknown>, R extends Runnable> = {
+    [key in keyof ExtractRunnableInputType<R>]: BindAgentInput<Vars, ExtractRunnableInputType<R>[key]>;
+};
+export interface AgentPreload {
+    id: string;
+    name?: string;
+    runnable?: {
+        id: string;
+    };
+    input?: {
+        [inputId: string]: BindAgentInput;
+    };
+}
+export type BindAgentInput<Vars extends Record<string, unknown> = Record<string, unknown>, Input = unknown> = {
+    from: "ai";
+} | {
+    from: "input";
+    fromInput: keyof {
+        [name in keyof Vars as Vars[name] extends Input ? name : never]: name;
+    };
+};
+export interface BoundAgent<Vars extends Record<string, unknown> = Record<string, unknown>, R extends Runnable = Runnable, I extends BindAgentInputs<Vars, R> = BindAgentInputs<Vars, R>> {
+    description?: string;
+    runnable: R;
+    input?: I;
+}
+type PickInputFrom<I, From extends BindAgentInput["from"]> = {
+    [key in keyof I as I[key] extends {
+        from: From;
+    } ? key : never]: I[key];
+};
+export type OmitBoundAgentInput<Case extends BoundAgent, From extends BindAgentInput["from"]> = Omit<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, Record<string, never>>, keyof PickInputFrom<Required<UnionToIntersection<NonNullable<Case["input"]>, Record<string, never>>>, From>>;
+export {};

package/lib/cjs/definitions/preload.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preloadCreatorsToPreloads = preloadCreatorsToPreloads;
+const is_non_nullable_1 = require("../utils/is-non-nullable");
+const ordered_map_1 = require("../utils/ordered-map");
+function preloadCreatorsToPreloads(inputs, creators) {
+    return ordered_map_1.OrderedRecord.fromArray(Object.entries(creators ?? {}).map(([name, preload]) => {
+        const p = preload((runnable, input, options) => ({
+            ...options,
+            runnable,
+            input,
+        }));
+        const input = Object.fromEntries(ordered_map_1.OrderedRecord.map(p.runnable.definition.inputs, (i) => {
+            if (!i.name)
+                return null;
+            const bind = p.input?.[i.name];
+            if (!bind)
+                return null;
+            if (bind.from !== "input")
+                throw new Error(`Unsupported bind from ${bind.from} in preloads`);
+            const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === bind.fromInput);
+            if (!from)
+                throw new Error(`Input ${bind.fromInput} not found`);
+            return [i.id, { ...bind, fromInput: from.id }];
+        }).filter(is_non_nullable_1.isNonNullable));
+        return {
+            id: name,
+            name,
+            description: p.description,
+            runnable: { id: p.runnable.id },
+            input,
+        };
+    }));
+}

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

@@ -1,64 +1,23 @@
-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, RunnableResponse, RunnableResponseChunk } 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<I, O, Memories, State>;
+import { type SchemaToType } from "./definitions/data-schema";
+import type { RunnableInput, RunnableOutput, RunnableResponse, RunnableResponseChunk } from "./runnable";
+export declare class FunctionAgent<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: FunctionAgentDefinition<I, O, State, Preloads, Memories>;
     static create: typeof create;
-    constructor(definition: FunctionAgentDefinition<I, O, Memories, State>, context?: Context<State>);
-    process(input: I, options: AgentProcessOptions<Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
+    constructor(definition: FunctionAgentDefinition<I, O, State, Preloads, Memories>, context?: Context<State>);
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<AsyncGenerator<RunnableResponseChunk<O>, void, any> | RunnableResponse<O>>;
 }
-export interface FunctionAgentDefinition<I extends {
-    [name: string]: any;
-}, O extends {
-    [name: string]: any;
-}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-}, State extends ContextState> extends RunnableDefinition {
+export interface FunctionAgentDefinition<I extends RunnableInput, O extends RunnableOutput, State extends ContextState, Preloads extends AgentPreloads, Memories extends AgentMemories> extends AgentDefinition {
     type: "function_agent";
-    function?: FunctionFuncType<I, O, Memories, State>;
+    function?: FunctionFuncType<I, O, State, Preloads, Memories>;
 }
-export type FunctionFuncType<I extends {
-    [name: string]: any;
-}, O extends {
-    [name: string]: any;
-}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-}, State extends ContextState> = (input: I, options: {
-    memories: Memories;
+export type FunctionFuncType<I extends RunnableInput, O extends RunnableOutput, State extends ContextState, Preloads extends AgentPreloads, Memories extends AgentMemories> = (input: AgentProcessInput<I, Preloads, Memories>, options: {
     context: Context<State>;
+    preloads: Preloads;
+    memories: Memories;
 }) => Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-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;
-    function?: FunctionFuncType<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 }: CreateFunctionAgentOptions<I, O, Memories, State>): FunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
+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> & {
+    function?: FunctionFuncType<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+}): FunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
 export {};

package/lib/cjs/function-agent.js

@@ -17,8 +17,9 @@ const nanoid_1 = require("nanoid");
 const tsyringe_1 = require("tsyringe");
 const agent_1 = require("./agent");
 const constants_1 = require("./constants");
-const data_type_schema_1 = require("./definitions/data-type-schema");
+const data_schema_1 = require("./definitions/data-schema");
 const memory_1 = require("./definitions/memory");
+const preload_1 = require("./definitions/preload");
 let FunctionAgent = class FunctionAgent extends agent_1.Agent {
     definition;
     static create = create;
@@ -32,7 +33,7 @@ let FunctionAgent = class FunctionAgent extends agent_1.Agent {
             throw new Error("Function is required");
         if (!context)
             throw new Error("Context is required");
-        return await func(input, { context, memories: options.memories });
+        return await func(input, { ...options, context });
     }
 };
 exports.FunctionAgent = FunctionAgent;
@@ -42,10 +43,11 @@ exports.FunctionAgent = FunctionAgent = __decorate([
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], FunctionAgent);
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
-    const inputs = (0, data_type_schema_1.schemaToDataType)(options.inputs);
-    const outputs = (0, data_type_schema_1.schemaToDataType)(options.outputs);
+    const inputs = (0, data_schema_1.schemaToDataType)(options.inputs);
+    const outputs = (0, data_schema_1.schemaToDataType)(options.outputs);
+    const preloads = (0, preload_1.preloadCreatorsToPreloads)(inputs, options.preloads);
     const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
     return new FunctionAgent({
         id: agentId,
@@ -53,7 +55,8 @@ function create({ context, ...options }) {
         type: "function_agent",
         inputs,
         outputs,
+        preloads,
         memories,
         function: options.function,
-    }, context);
+    }, options.context);
 }

package/lib/cjs/index.d.ts

@@ -2,7 +2,7 @@ export * from "./agent";
 export * from "./constants";
 export * from "./context";
 export * from "./definitions/data-type";
-export * from "./definitions/data-type-schema";
+export * from "./definitions/data-schema";
 export * from "./definitions/memory";
 export * from "./definitions/open-api";
 export * from "./function-agent";

package/lib/cjs/index.js

@@ -18,7 +18,7 @@ __exportStar(require("./agent"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./definitions/data-type"), exports);
-__exportStar(require("./definitions/data-type-schema"), exports);
+__exportStar(require("./definitions/data-schema"), exports);
 __exportStar(require("./definitions/memory"), exports);
 __exportStar(require("./definitions/open-api"), exports);
 __exportStar(require("./function-agent"), exports);