@aigne/core 1.0.8 → 1.0.10

package/lib/cjs/agent.d.ts

@@ -1,6 +1,7 @@
 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[];
 }> {
@@ -38,4 +39,13 @@ export declare abstract class Agent<I extends {
      */
     protected onResult(_result: O): Promise<void>;
     abstract process(input: I, options: AgentProcessOptions<Memories>): 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: {
+        description?: string;
+        input?: Input;
+    }): BoundAgent<typeof this, Readonly<Input>>;
 }

package/lib/cjs/agent.js

@@ -100,5 +100,16 @@ class Agent extends runnable_1.Runnable {
     async onResult(_result) {
         // Override this method to perform additional operations before the result is returned
     }
+    /**
+     * 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(options) {
+        return {
+            ...options,
+            runnable: this,
+        };
+    }
 }
 exports.Agent = Agent;

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

@@ -1,14 +1,12 @@
 import { Agent, type AgentProcessOptions } 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 { RunnableDefinition } from "./runnable";
 import { OrderedRecord } from "./utils";
-import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
-import type { UnionToIntersection } from "./utils/union";
+import type { BindAgentInput, BoundAgent, ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType, OmitBoundAgentInput } from "./utils/runnable-type";
 export declare class LLMDecisionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -22,30 +20,7 @@ export declare class LLMDecisionAgent<I extends {
     constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
     process(input: I, options: AgentProcessOptions<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>;
-    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 {
+declare function create<Case extends BoundAgent, I extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, O extends ExtractRunnableOutputType<Case["runnable"]>, Memories extends {
     [name: string]: CreateRunnableMemory<I> & {
         /**
          * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
@@ -55,7 +30,12 @@ declare function create<Case extends DecisionAgentCaseParameter, I extends Union
          */
         primary?: boolean;
     };
-}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, ExtractRunnableOutputType<Case["runnable"]>, {
+}, State extends ContextState>({ context, ...options }: Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> & {
+    context: Context<State>;
+    cases: {
+        [name: string]: Case;
+    };
+}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, ExtractRunnableOutputType<Case["runnable"]>, {
     [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
@@ -69,5 +49,8 @@ export interface LLMDecisionCase {
     runnable?: {
         id?: string;
     };
+    input?: {
+        [inputId: string]: BindAgentInput;
+    };
 }
 export {};

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

@@ -20,6 +20,7 @@ const constants_1 = require("./constants");
 const memory_1 = require("./definitions/memory");
 const utils_1 = require("./utils");
 const message_utils_1 = require("./utils/message-utils");
+const structured_output_schema_1 = require("./utils/structured-output-schema");
 let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.Agent {
     definition;
     model;
@@ -45,19 +46,23 @@ let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.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 = utils_1.OrderedRecord.fromArray(utils_1.OrderedRecord.filter(t.runnable.definition.inputs, (i) => t.input?.[i.id]?.from === "ai"));
+                const parameters = inputsFromAI.$indexes.length > 0
+                    ? (0, structured_output_schema_1.outputsToJsonSchema)(inputsFromAI)
+                    : {};
                 return {
                     type: "function",
                     function: {
                         name: t.name,
                         description: t.description,
-                        parameters: {},
+                        parameters,
                     },
                 };
             }),
@@ -65,14 +70,16 @@ let LLMDecisionAgent = class LLMDecisionAgent extends agent_1.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 (0, utils_1.extractOutputsFromRunnableOutput)(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
             {
@@ -92,12 +99,22 @@ exports.LLMDecisionAgent = LLMDecisionAgent = __decorate([
 ], LLMDecisionAgent);
 function create({ context, ...options }) {
     const agentId = options.name || (0, nanoid_1.nanoid)();
-    const cases = utils_1.OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => ({
-        id: (0, nanoid_1.nanoid)(),
-        name: name || c.runnable.name,
-        description: c.description,
-        runnable: { id: c.runnable.id },
-    })));
+    const cases = utils_1.OrderedRecord.fromArray(Object.entries(options.cases).map(([name, c]) => {
+        const bindInputs = Object.entries(c.input ?? {});
+        return {
+            id: (0, nanoid_1.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] ||
+                    utils_1.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 = utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.inputs));
     const outputs = utils_1.OrderedRecord.fromArray(utils_1.OrderedRecord.map(utils_1.OrderedRecord.merge(...Object.values(options.cases).map((i) => i.runnable.definition.outputs)), (o) => ({ ...o, required: false })));
     const memories = (0, memory_1.toRunnableMemories)(agentId, inputs, options.memories ?? {});

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

@@ -8,7 +8,9 @@ export declare class OpenaiLLMModel extends LLMModel {
     private client;
     setApiKey(apiKey: string): void;
     process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string | undefined;
+        $text: string;
+        delta?: undefined;
+    } | {
         delta: {
             toolCalls: {
                 id?: string;
@@ -19,5 +21,6 @@ export declare class OpenaiLLMModel extends LLMModel {
                 };
             }[];
         };
+        $text?: undefined;
     }, void, unknown>;
 }

package/lib/cjs/llm-models/openai-llm-model.js

@@ -43,22 +43,22 @@ class OpenaiLLMModel extends llm_model_1.LLMModel {
         const toolCalls = [];
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
-            const calls = choice?.delta.tool_calls?.map((i) => ({
-                id: i.id || (0, nanoid_1.nanoid)(),
-                type: "function",
-                function: {
-                    name: i.function?.name,
-                    arguments: i.function?.arguments,
-                },
-            }));
-            if (calls?.length) {
-                toolCalls.push(...calls);
+            if (choice?.delta.tool_calls?.length) {
+                for (const call of choice.delta.tool_calls) {
+                    const tool = toolCalls[call.index] ?? { id: call.id || (0, nanoid_1.nanoid)() };
+                    toolCalls[call.index] = tool;
+                    if (call.type)
+                        tool.type = call.type;
+                    tool.function ??= {};
+                    tool.function.name =
+                        (tool.function.name || "") + (call.function?.name || "");
+                    tool.function.arguments = (tool.function.arguments || "").concat(call.function?.arguments || "");
+                }
             }
-            yield {
-                $text: choice?.delta.content || undefined,
-                delta: { toolCalls },
-            };
+            if (choice?.delta.content)
+                yield { $text: choice.delta.content };
         }
+        yield { delta: { toolCalls } };
     }
 }
 exports.OpenaiLLMModel = OpenaiLLMModel;

package/lib/cjs/utils/runnable-type.d.ts

@@ -1,3 +1,23 @@
 import type { Runnable, 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;
+}

package/lib/dts/agent.d.ts

@@ -1,6 +1,7 @@
 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[];
 }> {
@@ -38,4 +39,13 @@ export declare abstract class Agent<I extends {
      */
     protected onResult(_result: O): Promise<void>;
     abstract process(input: I, options: AgentProcessOptions<Memories>): 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: {
+        description?: string;
+        input?: Input;
+    }): BoundAgent<typeof this, Readonly<Input>>;
 }

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

@@ -1,14 +1,12 @@
 import { Agent, type AgentProcessOptions } 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 { RunnableDefinition } from "./runnable";
 import { OrderedRecord } from "./utils";
-import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
-import type { UnionToIntersection } from "./utils/union";
+import type { BindAgentInput, BoundAgent, ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType, OmitBoundAgentInput } from "./utils/runnable-type";
 export declare class LLMDecisionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -22,30 +20,7 @@ export declare class LLMDecisionAgent<I extends {
     constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
     process(input: I, options: AgentProcessOptions<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>;
-    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 {
+declare function create<Case extends BoundAgent, I extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, O extends ExtractRunnableOutputType<Case["runnable"]>, Memories extends {
     [name: string]: CreateRunnableMemory<I> & {
         /**
          * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
@@ -55,7 +30,12 @@ declare function create<Case extends DecisionAgentCaseParameter, I extends Union
          */
         primary?: boolean;
     };
-}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, ExtractRunnableOutputType<Case["runnable"]>, {
+}, State extends ContextState>({ context, ...options }: Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> & {
+    context: Context<State>;
+    cases: {
+        [name: string]: Case;
+    };
+}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, ExtractRunnableOutputType<Case["runnable"]>, {
     [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
@@ -69,5 +49,8 @@ export interface LLMDecisionCase {
     runnable?: {
         id?: string;
     };
+    input?: {
+        [inputId: string]: BindAgentInput;
+    };
 }
 export {};

package/lib/dts/llm-models/openai-llm-model.d.ts

@@ -8,7 +8,9 @@ export declare class OpenaiLLMModel extends LLMModel {
     private client;
     setApiKey(apiKey: string): void;
     process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string | undefined;
+        $text: string;
+        delta?: undefined;
+    } | {
         delta: {
             toolCalls: {
                 id?: string;
@@ -19,5 +21,6 @@ export declare class OpenaiLLMModel extends LLMModel {
                 };
             }[];
         };
+        $text?: undefined;
     }, void, unknown>;
 }

package/lib/dts/utils/runnable-type.d.ts

@@ -1,3 +1,23 @@
 import type { Runnable, 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;
+}

package/lib/esm/agent.d.ts

@@ -1,6 +1,7 @@
 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[];
 }> {
@@ -38,4 +39,13 @@ export declare abstract class Agent<I extends {
      */
     protected onResult(_result: O): Promise<void>;
     abstract process(input: I, options: AgentProcessOptions<Memories>): 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: {
+        description?: string;
+        input?: Input;
+    }): BoundAgent<typeof this, Readonly<Input>>;
 }

package/lib/esm/agent.js

@@ -94,4 +94,15 @@ export class Agent extends Runnable {
     async onResult(_result) {
         // Override this method to perform additional operations before the result is returned
     }
+    /**
+     * 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(options) {
+        return {
+            ...options,
+            runnable: this,
+        };
+    }
 }

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

@@ -1,14 +1,12 @@
 import { Agent, type AgentProcessOptions } 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 { RunnableDefinition } from "./runnable";
 import { OrderedRecord } from "./utils";
-import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
-import type { UnionToIntersection } from "./utils/union";
+import type { BindAgentInput, BoundAgent, ExtractRunnableInputTypeIntersection, ExtractRunnableOutputType, OmitBoundAgentInput } from "./utils/runnable-type";
 export declare class LLMDecisionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -22,30 +20,7 @@ export declare class LLMDecisionAgent<I extends {
     constructor(definition: LLMDecisionAgentDefinition, context?: Context<State>, model?: LLMModel | undefined);
     process(input: I, options: AgentProcessOptions<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>;
-    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 {
+declare function create<Case extends BoundAgent, I extends ExtractRunnableInputTypeIntersection<Case["runnable"]>, O extends ExtractRunnableOutputType<Case["runnable"]>, Memories extends {
     [name: string]: CreateRunnableMemory<I> & {
         /**
          * Whether this memory is primary? Primary memory will be passed as messages to LLM chat model,
@@ -55,7 +30,12 @@ declare function create<Case extends DecisionAgentCaseParameter, I extends Union
          */
         primary?: boolean;
     };
-}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, ExtractRunnableOutputType<Case["runnable"]>, {
+}, State extends ContextState>({ context, ...options }: Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> & {
+    context: Context<State>;
+    cases: {
+        [name: string]: Case;
+    };
+}): LLMDecisionAgent<OmitBoundAgentInput<Case, "ai">, ExtractRunnableOutputType<Case["runnable"]>, {
     [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
@@ -69,5 +49,8 @@ export interface LLMDecisionCase {
     runnable?: {
         id?: string;
     };
+    input?: {
+        [inputId: string]: BindAgentInput;
+    };
 }
 export {};

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

@@ -17,6 +17,7 @@ import { TYPES } from "./constants";
 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,
             {
@@ -89,12 +96,22 @@ LLMDecisionAgent = __decorate([
 export { LLMDecisionAgent };
 function create({ context, ...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 ?? {});

package/lib/esm/llm-models/openai-llm-model.d.ts

@@ -8,7 +8,9 @@ export declare class OpenaiLLMModel extends LLMModel {
     private client;
     setApiKey(apiKey: string): void;
     process(input: LLMModelInputs): AsyncGenerator<{
-        $text: string | undefined;
+        $text: string;
+        delta?: undefined;
+    } | {
         delta: {
             toolCalls: {
                 id?: string;
@@ -19,5 +21,6 @@ export declare class OpenaiLLMModel extends LLMModel {
                 };
             }[];
         };
+        $text?: undefined;
     }, void, unknown>;
 }

package/lib/esm/llm-models/openai-llm-model.js

@@ -37,22 +37,22 @@ export class OpenaiLLMModel extends LLMModel {
         const toolCalls = [];
         for await (const chunk of res) {
             const choice = chunk.choices?.[0];
-            const calls = choice?.delta.tool_calls?.map((i) => ({
-                id: i.id || nanoid(),
-                type: "function",
-                function: {
-                    name: i.function?.name,
-                    arguments: i.function?.arguments,
-                },
-            }));
-            if (calls?.length) {
-                toolCalls.push(...calls);
+            if (choice?.delta.tool_calls?.length) {
+                for (const call of choice.delta.tool_calls) {
+                    const tool = toolCalls[call.index] ?? { id: call.id || nanoid() };
+                    toolCalls[call.index] = tool;
+                    if (call.type)
+                        tool.type = call.type;
+                    tool.function ??= {};
+                    tool.function.name =
+                        (tool.function.name || "") + (call.function?.name || "");
+                    tool.function.arguments = (tool.function.arguments || "").concat(call.function?.arguments || "");
+                }
             }
-            yield {
-                $text: choice?.delta.content || undefined,
-                delta: { toolCalls },
-            };
+            if (choice?.delta.content)
+                yield { $text: choice.delta.content };
         }
+        yield { delta: { toolCalls } };
     }
 }
 async function contentsFromInputMessages(messages) {

package/lib/esm/utils/runnable-type.d.ts

@@ -1,3 +1,23 @@
 import type { Runnable, 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"
@@ -24,14 +24,14 @@
     "url": "git+https://github.com/blocklet/ai-studio.git"
   },
   "dependencies": {
+    "@google/generative-ai": "^0.21.0",
     "@types/mustache": "^4.2.5",
     "lodash": "^4.17.21",
     "mustache": "^4.2.0",
     "nanoid": "^5.0.9",
-    "tsyringe": "^4.8.0",
-    "ufo": "^1.5.4",
     "openai": "^4.79.1",
-    "@google/generative-ai": "^0.21.0"
+    "tsyringe": "^4.8.0",
+    "ufo": "^1.5.4"
   },
   "peerDependencies": {
     "@google/generative-ai": "^0.21.0",