@aigne/core 1.0.9 → 1.0.11

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);
 }

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

@@ -18,8 +18,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 SandboxFunctionAgent = class SandboxFunctionAgent extends agent_1.Agent {
     definition;
     runner;
@@ -43,6 +44,7 @@ let SandboxFunctionAgent = class SandboxFunctionAgent extends agent_1.Agent {
             language,
             code,
             input,
+            preloads: options.preloads,
             memories: options.memories,
             context: { state: context.state },
         }, { stream: true });
@@ -56,10 +58,11 @@ exports.SandboxFunctionAgent = SandboxFunctionAgent = __decorate([
     __param(2, (0, tsyringe_1.inject)(constants_1.TYPES.sandboxFunctionRunner)),
     __metadata("design:paramtypes", [Object, Object, Function])
 ], SandboxFunctionAgent);
-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 SandboxFunctionAgent({
         id: agentId,
@@ -67,8 +70,9 @@ function create({ context, ...options }) {
         type: "sandbox_function_agent",
         inputs,
         outputs,
+        preloads,
         memories,
         language: options.language,
         code: options.code,
-    }, context);
+    }, options.context);
 }

package/lib/cjs/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/cjs/sandbox-function-runner.js

@@ -15,6 +15,7 @@ class SandboxFunctionRunner extends agent_1.Agent {
                 { id: "language", name: "language", type: "string" },
                 { id: "code", name: "code", type: "string", required: true },
                 { id: "input", name: "input", type: "object", required: true },
+                { id: "preloads", name: "preloads", type: "object", required: true },
                 { id: "memories", name: "memories", type: "object", required: true },
                 { id: "context", name: "context", type: "object", required: true },
             ]),

package/lib/cjs/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/cjs/utils/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./fetch"), exports);
 __exportStar(require("./fetch-open-api"), exports);
 __exportStar(require("./is-non-nullable"), exports);
+__exportStar(require("./logger"), exports);
 __exportStar(require("./mustache-utils"), exports);
 __exportStar(require("./nullable"), exports);
 __exportStar(require("./omit"), exports);

package/lib/cjs/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/cjs/utils/logger.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+function logLevel() {
+    return process.env.LOG_LEVEL || "info";
+}
+function createLogger(logger, level = logLevel()) {
+    return {
+        debug: level === "debug" ? logger.debug : () => { },
+        info: level === "debug" || level === "info" ? logger.info : () => { },
+        warn: level === "debug" || level === "info" || level === "warn"
+            ? logger.warn
+            : () => { },
+        error: logger.error,
+    };
+}
+exports.logger = createLogger(console);

package/lib/cjs/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/cjs/utils/message-utils.js

@@ -49,12 +49,9 @@ function memoriesToMessages(memories, { primaryMemoryName } = {}) {
     };
 }
 function prepareMessages(definition, input, memories) {
-    const variables = { ...input, ...memories };
     const originalMessages = ordered_map_1.OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
         role,
-        content: typeof content === "string"
-            ? (0, mustache_utils_1.renderMessage)(content, variables)
-            : content,
+        content: typeof content === "string" ? (0, mustache_utils_1.renderMessage)(content, input) : content,
     }));
     if (!originalMessages.length)
         throw new Error("Messages are required");

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

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatOpenAPIRequest = formatOpenAPIRequest;
 const lodash_1 = require("lodash");
-const logger_1 = __importDefault(require("../logger"));
+const logger_1 = require("./logger");
 const ordered_map_1 = require("./ordered-map");
 async function formatOpenAPIRequest(api, inputs, input) {
     const { url, method, ...inputParams } = processParameters(api, inputs, input);
-    logger_1.default.debug("inputParams", inputParams);
+    logger_1.logger.debug("inputParams", inputParams);
     const authParams = await getAuthParams(api.auth);
-    logger_1.default.debug("authParams", authParams);
+    logger_1.logger.debug("authParams", authParams);
     return {
         url,
         method,

package/lib/cjs/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/cjs/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/cjs/utils/type-utils.d.ts

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

package/lib/cjs/{logger.js → utils/type-utils.js}

@@ -1,4 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger = console;
-exports.default = logger;

package/lib/dts/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/dts/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;