@aigne/core 1.0.10 → 1.0.11

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

@@ -1,23 +1,15 @@
-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 SchemaToType } from "./definitions/data-schema";
 import type { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
-import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
-import type { RunnableDefinition } from "./runnable";
+import type { RunnableInput, RunnableOutput } 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> {
+export declare class LLMAgent<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: LLMAgentDefinition;
     model?: LLMModel | undefined;
     static create: typeof create;
     constructor(definition: LLMAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
-    process(input: I, options: AgentProcessOptions<Memories>): AsyncGenerator<{
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions): AsyncGenerator<{
         $text: string | undefined;
         delta?: undefined;
     } | {
@@ -27,7 +19,7 @@ export declare class LLMAgent<I extends {
     private runWithStructuredOutput;
     private runWithTextOutput;
 }
-export interface LLMAgentDefinition extends RunnableDefinition {
+export interface LLMAgentDefinition extends AgentDefinition {
     type: "llm_agent";
     primaryMemoryId?: string;
     messages?: OrderedRecord<LLMModelInputMessage & {
@@ -36,32 +28,19 @@ export interface LLMAgentDefinition extends RunnableDefinition {
     modelOptions?: LLMModelInputs["modelOptions"];
 }
 /**
- * Options to create LLMAgent.
+ * Create LLMAgent definition.
+ * @param options Options to create LLMAgent.
+ * @returns LLMAgent definition.
  */
-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;
+declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I, {
     /**
-     * Output variables for this agent.
+     * 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.
      */
-    outputs: O;
-    /**
-     * Memories to be used in this agent.
-     */
-    memories?: Memories;
+    primary?: boolean;
+}>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
     /**
      * Options for LLM chat model.
      */
@@ -70,27 +49,5 @@ export interface CreateLLMAgentOptions<I extends {
      * 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>;
+}): LLMAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
 export {};

package/lib/cjs/llm-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");
 const message_utils_1 = require("./utils/message-utils");
 const mustache_utils_1 = require("./utils/mustache-utils");
 const ordered_map_1 = require("./utils/ordered-map");
@@ -104,10 +105,11 @@ exports.LLMAgent = LLMAgent = __decorate([
  * @param options Options to create LLMAgent.
  * @returns LLMAgent definition.
  */
-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 ?? {});
     const primaryMemoryNames = Object.entries(options.memories ?? {})
         .filter(([, i]) => i.primary)
@@ -126,9 +128,10 @@ function create({ context, ...options }) {
         type: "llm_agent",
         inputs,
         outputs,
+        preloads,
         primaryMemoryId: primaryMemoryNames?.at(0),
         memories,
         modelOptions: options.modelOptions,
         messages,
-    }, context);
+    }, options.context);
 }

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

@@ -1,44 +1,41 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } from "./agent";
 import type { Context, ContextState } from "./context";
-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 { RunnableDefinition } from "./runnable";
+import type { TypeToSchema } from "./definitions/data-schema";
+import type { BindAgentInput, BoundAgent, OmitBoundAgentInput } from "./definitions/preload";
+import type { LLMAgentDefinition } from "./llm-agent";
+import type { LLMModel, LLMModelInputMessage, LLMModelInputs } from "./llm-model";
+import type { RunnableInput, RunnableOutput } from "./runnable";
 import { OrderedRecord } from "./utils";
-import type { BindAgentInput, BoundAgent, ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType, OmitBoundAgentInput } from "./utils/runnable-type";
-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> {
+import type { ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType } from "./utils/runnable-type";
+export declare class LLMDecisionAgent<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: 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>>;
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("./runnable").RunnableResponse<O>>;
 }
-declare function create<Case extends BoundAgent, I extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, O extends ExtractRunnableOutputType<Case["runnable"]>, 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 }: Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> & {
-    context: Context<State>;
+declare function create<Case extends BoundAgent, InputType extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, OutputType extends ExtractRunnableOutputType<Case["runnable"]>, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<TypeToSchema<InputType>>, Memories extends CreateAgentMemoriesSchema<TypeToSchema<InputType>, {
+    /**
+     * 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;
+}>>(options: Omit<CreateAgentOptions<never, never, State, Preloads, Memories>, "inputs" | "outputs"> & {
     cases: {
         [name: string]: Case;
     };
-}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, ExtractRunnableOutputType<Case["runnable"]>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
-export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
+    /**
+     * Options for LLM chat model.
+     */
+    modelOptions?: LLMModelInputs["modelOptions"];
+    /**
+     * Messages to be passed to LLM chat model.
+     */
+    messages?: LLMModelInputMessage[];
+}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, OutputType, State, CreateAgentPreloadsType<TypeToSchema<InputType>, Preloads>, CreateAgentMemoriesType<TypeToSchema<InputType>, Memories>>;
+export interface LLMDecisionAgentDefinition extends AgentDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
     type: "llm_decision_agent";
     cases?: OrderedRecord<LLMDecisionCase>;
 }

package/lib/cjs/llm-decision-agent.js

@@ -97,7 +97,7 @@ exports.LLMDecisionAgent = LLMDecisionAgent = __decorate([
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.llmModel)),
     __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMDecisionAgent);
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
     const cases = utils_1.OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => {
         const bindInputs = Object.entries(c.input ?? {});
@@ -140,5 +140,5 @@ function create({ context, ...options }) {
         memories,
         modelOptions: options.modelOptions,
         cases,
-    }, context);
+    }, options.context);
 }

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

@@ -1,7 +1,7 @@
 import { Agent } from "./agent";
 import type { Context } from "./context";
 export type Role = "system" | "user" | "assistant" | "tool";
-export interface LLMModelInputs {
+export type LLMModelInputs = {
     messages: LLMModelInputMessage[];
     responseFormat?: {
         type: "text";
@@ -23,7 +23,7 @@ export interface LLMModelInputs {
         };
     };
     modelOptions?: LLMModelOptions;
-}
+};
 export interface LLMModelInputMessage {
     role: Role;
     content: string | ({
@@ -60,7 +60,7 @@ export interface LLMModelOptions {
     frequencyPenalty?: number;
     presencePenalty?: number;
 }
-export interface LLMModelOutputs {
+export type LLMModelOutputs = {
     $text?: string | null;
     toolCalls?: {
         id?: string;
@@ -70,7 +70,7 @@ export interface LLMModelOutputs {
             arguments?: string;
         };
     }[];
-}
+};
 export declare abstract class LLMModel extends Agent<LLMModelInputs, LLMModelOutputs> {
     constructor(context?: Context);
 }

package/lib/cjs/memorable.d.ts

@@ -1,8 +1,7 @@
+import type { Context } from "./context";
 import type { LLMModelInputMessage } from "./llm-model";
 import { Runnable } from "./runnable";
-export interface MemoryMetadata {
-    [key: string]: any;
-}
+export type MemoryMetadata = Record<string, unknown>;
 export type MemoryActionItem<T> = {
     event: "add";
     id: string;
@@ -31,7 +30,7 @@ export interface MemoryItem<T> {
     memory: T;
     metadata: MemoryMetadata;
 }
-export interface MemoryItemWithScore<T = any> extends MemoryItem<T> {
+export interface MemoryItemWithScore<T = unknown> extends MemoryItem<T> {
     score: number;
 }
 export type MemoryMessage = LLMModelInputMessage;
@@ -110,13 +109,19 @@ export type MemoryActions<T> = {
 } | {
     action: "delete";
     inputs: {
-        filter: string | string[] | Record<string, any>;
+        filter: string | string[] | Record<string, unknown>;
+    };
+    outputs: {
+        [name: string]: never;
     };
-    outputs: {};
 } | {
     action: "reset";
-    inputs: {};
-    outputs: {};
+    inputs: {
+        [name: string]: never;
+    };
+    outputs: {
+        [name: string]: never;
+    };
 };
 export interface SortItem {
     field: string;
@@ -124,7 +129,7 @@ export interface SortItem {
 }
 export type MemorySortOptions = SortItem | SortItem[];
 export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
-    constructor();
+    constructor(context?: Context);
     abstract runner?: MemoryRunner<T, C>;
     abstract add(messages: Extract<MemoryActions<T>, {
         action: "add";
@@ -169,15 +174,18 @@ export declare abstract class Memorable<T, C = undefined> extends Runnable<Memor
     }>["outputs"]>;
     abstract reset(): Promise<void>;
 }
-export interface MemoryRunnerInput<C = undefined> {
+export type 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>[]> {
+};
+export type MemoryRunnerOutput<T> = {
+    actions: MemoryActionItem<T>[];
+};
+export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryRunnerOutput<T>> {
     constructor(name: string);
 }
-export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T["search"]>>["results"];
+export type MemorableSearchOutput<T extends Memorable<unknown>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/cjs/memorable.js

@@ -5,14 +5,14 @@ const lodash_1 = require("lodash");
 const runnable_1 = require("./runnable");
 const utils_1 = require("./utils");
 class Memorable extends runnable_1.Runnable {
-    constructor() {
+    constructor(context) {
         super({
             id: "memory",
             type: "memory",
             name: "Memory",
             inputs: utils_1.OrderedRecord.fromArray([]),
             outputs: utils_1.OrderedRecord.fromArray([]),
-        });
+        }, context);
     }
 }
 exports.Memorable = Memorable;

package/lib/cjs/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/cjs/open-api-agent.js

@@ -17,7 +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");
 const fetch_open_api_1 = require("./utils/fetch-open-api");
 const open_api_parameter_1 = require("./utils/open-api-parameter");
 let OpenAPIAgent = class OpenAPIAgent extends agent_1.Agent {
@@ -45,18 +47,22 @@ exports.OpenAPIAgent = OpenAPIAgent = __decorate([
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], OpenAPIAgent);
-function create({ context, ...options }) {
-    const agentId = options.id || 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);
+function create(options) {
+    const agentId = options.name || (0, nanoid_1.nanoid)();
+    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 OpenAPIAgent({
         id: agentId,
         name: options.name,
         type: "open_api_agent",
         inputs,
+        preloads,
+        memories,
         outputs,
         url: options.url,
         method: options.method,
         auth: options.auth,
-    }, context);
+    }, options.context);
 }

package/lib/cjs/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/cjs/pipeline-agent.js

@@ -11,9 +11,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PipelineAgent = void 0;
 const lodash_1 = require("lodash");
@@ -21,10 +18,11 @@ 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 logger_1 = __importDefault(require("./logger"));
+const preload_1 = require("./definitions/preload");
 const is_non_nullable_1 = require("./utils/is-non-nullable");
+const logger_1 = require("./utils/logger");
 const ordered_map_1 = require("./utils/ordered-map");
 let PipelineAgent = class PipelineAgent extends agent_1.Agent {
     definition;
@@ -59,7 +57,7 @@ let PipelineAgent = class PipelineAgent extends agent_1.Agent {
                     let result = {};
                     for (const process of ordered_map_1.OrderedRecord.iterator(processes)) {
                         if (!process.runnable?.id) {
-                            logger_1.default.warn("Runnable id is required for process", process);
+                            logger_1.logger.warn("Runnable id is required for process", process);
                             continue;
                         }
                         const runnable = await context.resolve(process.runnable.id);
@@ -144,9 +142,10 @@ exports.PipelineAgent = PipelineAgent = __decorate([
     __param(1, (0, tsyringe_1.inject)(constants_1.TYPES.context)),
     __metadata("design:paramtypes", [Object, Object])
 ], PipelineAgent);
-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 inputs = (0, data_schema_1.schemaToDataType)(options.inputs);
+    const preloads = (0, preload_1.preloadCreatorsToPreloads)(inputs, options.preloads);
     const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories || {});
     const processes = ordered_map_1.OrderedRecord.fromArray([]);
     for (const [name, p] of Object.entries(options.processes)) {
@@ -178,7 +177,7 @@ function create({ context, ...options }) {
             }).filter(is_non_nullable_1.isNonNullable)),
         });
     }
-    const outputs = ordered_map_1.OrderedRecord.fromArray(ordered_map_1.OrderedRecord.map((0, data_type_schema_1.schemaToDataType)(options.outputs), (output) => {
+    const outputs = ordered_map_1.OrderedRecord.fromArray(ordered_map_1.OrderedRecord.map((0, data_schema_1.schemaToDataType)(options.outputs), (output) => {
         const { fromVariable, fromVariablePropPath } = options.outputs[output.name];
         const from = ordered_map_1.OrderedRecord.find(inputs, (i) => i.name === fromVariable) ||
             ordered_map_1.OrderedRecord.find(processes, (p) => p.name === fromVariable);
@@ -196,8 +195,9 @@ function create({ context, ...options }) {
         name: options.name,
         type: "pipeline_agent",
         inputs,
+        preloads,
         memories,
         outputs,
         processes,
-    }, context);
+    }, options.context);
 }