@aigne/core 1.0.9 → 1.0.11

package/lib/esm/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/esm/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/esm/definitions/preload.d.ts

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

package/lib/esm/definitions/preload.js

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

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

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

package/lib/esm/function-agent.js

@@ -12,10 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
-import { toRunnableMemories, } from "./definitions/memory";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 let FunctionAgent = class FunctionAgent extends Agent {
     definition;
     static create = create;
@@ -29,7 +30,7 @@ let FunctionAgent = class FunctionAgent extends Agent {
             throw new Error("Function is required");
         if (!context)
             throw new Error("Context is required");
-        return await func(input, { context, memories: options.memories });
+        return await func(input, { ...options, context });
     }
 };
 FunctionAgent = __decorate([
@@ -39,10 +40,11 @@ FunctionAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object])
 ], FunctionAgent);
 export { FunctionAgent };
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
     const memories = toRunnableMemories(agentId, inputs, options.memories || {});
     return new FunctionAgent({
         id: agentId,
@@ -50,7 +52,8 @@ function create({ context, ...options }) {
         type: "function_agent",
         inputs,
         outputs,
+        preloads,
         memories,
         function: options.function,
-    }, context);
+    }, options.context);
 }

package/lib/esm/index.d.ts

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

package/lib/esm/index.js

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

package/lib/esm/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/esm/llm-agent.js

@@ -12,10 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { StreamTextOutputName, TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
-import { toRunnableMemories, } from "./definitions/memory";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 import { prepareMessages } from "./utils/message-utils";
 import { renderMessage } from "./utils/mustache-utils";
 import { OrderedRecord } from "./utils/ordered-map";
@@ -101,10 +102,11 @@ export { LLMAgent };
  * @param options Options to create LLMAgent.
  * @returns LLMAgent definition.
  */
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
     const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
     const primaryMemoryNames = Object.entries(options.memories ?? {})
         .filter(([, i]) => i.primary)
@@ -123,9 +125,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/esm/llm-decision-agent.d.ts

@@ -1,64 +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 { DataTypeSchema } from "./definitions/data-type-schema";
-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 { Runnable, 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 { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
-import type { UnionToIntersection } from "./utils/union";
-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>>;
 }
-export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
-    description?: string;
-    runnable: R;
-}
-/**
- * Options to create LLMDecisionAgent.
- */
-export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
-    [name: string]: DataTypeSchema;
-}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
-    [name: string]: DataTypeSchema;
-}>, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> extends 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;
     };
-}
-declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
-    [name: string]: DataTypeSchema;
-}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
-    [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 }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, 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>;
 }
@@ -69,5 +46,8 @@ export interface LLMDecisionCase {
     runnable?: {
         id?: string;
     };
+    input?: {
+        [inputId: string]: BindAgentInput;
+    };
 }
 export {};

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

@@ -12,11 +12,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { TYPES } from "./constants";
-import { toRunnableMemories, } from "./definitions/memory";
+import { toRunnableMemories } from "./definitions/memory";
 import { OrderedRecord, extractOutputsFromRunnableOutput, renderMessage, } from "./utils";
 import { prepareMessages } from "./utils/message-utils";
+import { outputsToJsonSchema } from "./utils/structured-output-schema";
 let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
     definition;
     model;
@@ -42,19 +43,23 @@ let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
             const name = t.name || runnable.name;
             if (!name)
                 throw new Error("Case name is required");
-            return { name, description: t.description, runnable };
+            return { ...t, name, runnable };
         }));
         const llmInputs = {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
             tools: cases.map((t) => {
-                // TODO: auto generate parameters by llm model if needed
+                // Filter inputs that are bound from AI
+                const inputsFromAI = OrderedRecord.fromArray(OrderedRecord.filter(t.runnable.definition.inputs, (i) => t.input?.[i.id]?.from === "ai"));
+                const parameters = inputsFromAI.$indexes.length > 0
+                    ? outputsToJsonSchema(inputsFromAI)
+                    : {};
                 return {
                     type: "function",
                     function: {
                         name: t.name,
                         description: t.description,
-                        parameters: {},
+                        parameters,
                     },
                 };
             }),
@@ -62,14 +67,16 @@ let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
         };
         const { toolCalls } = await model.run(llmInputs);
         // TODO: support run multiple calls
-        const functionNameToCall = toolCalls?.[0]?.function?.name;
+        const { name: functionNameToCall, arguments: args } = toolCalls?.[0]?.function ?? {};
         if (!functionNameToCall)
             throw new Error("No any runnable called");
         const caseToCall = cases.find((i) => i.name === functionNameToCall);
         if (!caseToCall)
             throw new Error("Case not found");
+        // Prepare arguments generated by LLM model
+        const llmArgs = args ? JSON.parse(args) : {};
         // TODO: check result structure and omit undefined values
-        const output = await caseToCall.runnable.run(input, { stream: true });
+        const output = await caseToCall.runnable.run({ ...input, ...llmArgs }, { stream: true });
         return extractOutputsFromRunnableOutput(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
             {
@@ -87,14 +94,24 @@ LLMDecisionAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
-function create({ context, ...options }) {
+function create(options) {
     const agentId = options.name || nanoid();
-    const cases = OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => ({
-        id: nanoid(),
-        name: name || c.runnable.name,
-        description: c.description,
-        runnable: { id: c.runnable.id },
-    })));
+    const cases = OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => {
+        const bindInputs = Object.entries(c.input ?? {});
+        return {
+            id: nanoid(),
+            name: name || c.runnable.name,
+            description: c.description,
+            runnable: { id: c.runnable.id },
+            input: Object.fromEntries(bindInputs.map(([inputName, v]) => {
+                const input = c.runnable.definition.inputs[inputName] ||
+                    OrderedRecord.find(c.runnable.definition.inputs, (i) => i.name === inputName);
+                if (!input)
+                    throw new Error(`Input ${inputName} not found`);
+                return [input.id, v];
+            })),
+        };
+    }));
     const inputs = OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.inputs));
     const outputs = OrderedRecord.fromArray(OrderedRecord.map(OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.outputs)), (o) => ({ ...o, required: false })));
     const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
@@ -120,5 +137,5 @@ function create({ context, ...options }) {
         memories,
         modelOptions: options.modelOptions,
         cases,
-    }, context);
+    }, options.context);
 }