@aigne/core 1.0.10 → 1.0.11

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,23 +1,5 @@
-import type { Runnable, RunnableResponseStream } from "../runnable";
+import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
 import type { UnionToIntersection } from "./union";
-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;
-export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, {}>;
-export type ExtractRunnableOutputTypeIntersection<T> = UnionToIntersection<ExtractRunnableOutputType<T>, {}>;
-export type BindAgentInput = {
-    from: "ai";
-};
-export 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"]>, {}>, keyof PickInputFrom<Required<UnionToIntersection<NonNullable<Case["input"]>, {}>>, From>>;
-export type BindAgentInputs<R extends Runnable> = {
-    [key in keyof ExtractRunnableInputType<R>]?: BindAgentInput;
-};
-export interface BoundAgent<R extends Runnable = Runnable, I extends BindAgentInputs<R> = BindAgentInputs<R>> {
-    description?: string;
-    runnable: R;
-    input?: I;
-}
+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,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/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;

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