@aigne/core 1.9.0 → 1.11.0

package/lib/dts/execution-engine/context.d.ts

@@ -1,5 +1,5 @@
 import EventEmitter from "node:events";
-import { Agent, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { Agent, type AgentCallOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type FunctionAgentFn, type Message } from "../agents/agent.js";
 import { UserAgent } from "../agents/user-agent.js";
 import type { ChatModel } from "../models/chat-model.js";
 import { type OmitPropertiesFromArrayFirstElement } from "../utils/type-utils.js";
@@ -27,7 +27,7 @@ export interface ContextEventMap {
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
-export interface CallOptions {
+export interface CallOptions extends AgentCallOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
@@ -48,19 +48,30 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
      * @param agent Agent to call
      * @param message Message to pass to the agent
      * @param options.returnActiveAgent return the active agent
+     * @param options.streaming return a stream of the output
      * @returns the output of the agent and the final active agent
      */
     call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
         returnActiveAgent: true;
+        streaming?: false;
     }): Promise<[O, Runnable]>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Runnable>]>;
     /**
      * Call an agent with a message
      * @param agent Agent to call
      * @param message Message to pass to the agent
      * @returns the output of the agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: CallOptions): Promise<O>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): UserAgent<I, O> | Promise<O | [O, Runnable]>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options?: CallOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message?: I | string, options?: CallOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Runnable]>;
     /**
      * Publish a message to a topic, the engine will call the listeners of the topic
      * @param topic topic name, or an array of topic names
@@ -99,6 +110,7 @@ export declare class ExecutionContext implements Context {
         reset?: boolean;
     }): ExecutionContext;
     call: Context["call"];
+    private onCallSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
@@ -122,9 +134,8 @@ declare class ExecutionContextInternal {
     private timer?;
     private initTimeout;
     get status(): "normal" | "timeout";
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): Promise<{
-        agent: Runnable;
-        output: O;
+    call<I extends Message, O extends Message>(agent: Runnable<I, O>, input: I, context: Context, options?: CallOptions): AgentProcessAsyncGenerator<O & {
+        __activeAgent__: Runnable;
     }>;
     private callAgent;
 }

package/lib/dts/loader/agent-js.d.ts

@@ -4,12 +4,12 @@ export declare function loadAgentFromJsFile(path: string): Promise<{
     name: string;
     fn: (args_0: Message) => Message;
     description?: string | undefined;
-    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;

package/lib/dts/loader/agent-yaml.d.ts

@@ -2,21 +2,24 @@ import { type ZodObject, type ZodType, z } from "zod";
 export declare function loadAgentFromYamlFile(path: string): Promise<{
     type: "ai";
     name: string;
-    description?: string | undefined;
     tools?: string[] | undefined;
+    description?: string | undefined;
     instructions?: string | undefined;
-    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    memory?: true | {
+        subscribeTopic: string[];
+    } | undefined;
+    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    tool_choice?: "auto" | "none" | "required" | "router" | undefined;
-    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+    toolChoice?: "auto" | "none" | "required" | "router" | undefined;
+    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    output_key?: string | undefined;
+    outputKey?: string | undefined;
 } | {
     type: "mcp";
     url?: string | undefined;

package/lib/dts/loader/index.d.ts

@@ -8,8 +8,8 @@ export declare function load(options: LoadOptions): Promise<{
     model: ChatModel | undefined;
     agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
-    description?: string | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -63,9 +63,9 @@ declare const aigneFileSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
-    description?: string | null | undefined;
     tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -76,9 +76,9 @@ declare const aigneFileSchema: z.ZodObject<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }, {
-    description?: string | null | undefined;
     tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -90,9 +90,9 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
-    description?: string | null | undefined;
     tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;

package/lib/dts/models/chat-model.d.ts

@@ -2,6 +2,10 @@ import { Agent, type Message } from "../agents/agent.js";
 import type { Context } from "../execution-engine/context.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
+    protected supportsParallelToolCalls: boolean;
+    getModelCapabilities(): {
+        supportsParallelToolCalls: boolean;
+    };
     protected preprocess(input: ChatModelInput, context: Context): void;
     protected postprocess(input: ChatModelInput, output: ChatModelOutput, context: Context): void;
 }

package/lib/dts/models/claude-chat-model.d.ts

@@ -1,5 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
+import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface ClaudeChatModelOptions {
     apiKey?: string;
@@ -60,7 +62,7 @@ export declare class ClaudeChatModel extends ChatModel {
     protected _client?: Anthropic;
     get client(): Anthropic;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<ChatModelOutput>>;
     private extractResultFromClaudeStream;
     private requestStructuredOutput;
 }

package/lib/dts/models/open-router-chat-model.d.ts

@@ -2,4 +2,5 @@ import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-mode
 export declare class OpenRouterChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;
+    protected supportsParallelToolCalls: boolean;
 }

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

@@ -1,8 +1,17 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
-import type { Stream } from "openai/streaming.js";
 import { z } from "zod";
+import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
 import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
+export interface OpenAIChatModelCapabilities {
+    supportsNativeStructuredOutputs: boolean;
+    supportsEndWithSystemMessage: boolean;
+    supportsToolsUseWithJsonSchema: boolean;
+    supportsParallelToolCalls: boolean;
+    supportsToolsEmptyParameters: boolean;
+    supportsTemperature: boolean;
+}
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -71,9 +80,10 @@ export declare class OpenAIChatModel extends ChatModel {
     protected supportsToolsUseWithJsonSchema: boolean;
     protected supportsParallelToolCalls: boolean;
     protected supportsToolsEmptyParameters: boolean;
+    protected supportsTemperature: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<ChatModelOutput>>;
     private getParallelToolCalls;
     private getRunMessages;
     private getRunResponseFormat;
@@ -87,4 +97,3 @@ export declare function toolsFromInputTools(tools?: ChatModelInputTool[], option
     addTypeToEmptyParameters?: boolean;
 }): ChatCompletionTool[] | undefined;
 export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
-export declare function extractResultFromStream(stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>, jsonMode?: boolean): Promise<ChatModelOutput>;

package/lib/dts/utils/camelize.d.ts

@@ -0,0 +1,13 @@
+export declare function customCamelize<T extends Record<string, unknown>, K extends KeyofUnion<T> = never>(obj: T, { shallowKeys }?: {
+    shallowKeys?: K[];
+}): CustomCamelize<T, K>;
+type KeyofUnion<U> = U extends Record<string, unknown> ? keyof U : never;
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S;
+declare const _unique: unique symbol;
+type _never = typeof _unique;
+type ExtractTypeFromUnion<T, U> = Extract<T, U> extends never ? _never : Extract<T, U> extends Array<infer E> ? Array<E> : U;
+type ExtractTypeWithConstFromUnion<T, U> = Exclude<T, Exclude<T, U>>;
+export type CustomCamelize<T, ShallowKeys extends KeyofUnion<T> | undefined = undefined> = ExtractTypeFromUnion<T, never> extends never ? never : ExtractTypeFromUnion<T, Date> extends Date ? ExtractTypeWithConstFromUnion<T, Date> | CustomCamelize<Exclude<T, Date>> : ExtractTypeFromUnion<T, RegExp> extends RegExp ? ExtractTypeWithConstFromUnion<T, RegExp> | CustomCamelize<Exclude<T, RegExp>> : ExtractTypeFromUnion<T, Array<unknown>> extends Array<infer U> ? Array<CustomCamelize<U>> | CustomCamelize<Exclude<T, Array<U>>> : ExtractTypeFromUnion<T, Function> extends Function ? ExtractTypeWithConstFromUnion<T, Function> | CustomCamelize<Exclude<T, Function>> : ExtractTypeFromUnion<T, object> extends object ? {
+    [K in keyof T as Uncapitalize<CamelCase<string & K>>]: K extends Exclude<ShallowKeys, undefined> ? T[K] : CustomCamelize<T[K]>;
+} : T;
+export {};

package/lib/dts/utils/stream-utils.d.ts

@@ -0,0 +1,17 @@
+import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { MESSAGE_KEY } from "../prompt/prompt-builder.js";
+import { type PromiseOrValue } from "./type-utils.js";
+export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
+export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
+export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
+export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
+export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
+    errorCallback?: (error: Error) => Error;
+    processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
+}): ReadableStream<any>;
+export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
+export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
+export declare function arrayToAgentResponseStream<T>(chunks: (AgentResponseChunk<T> | Error)[]): AgentResponseStream<T>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>): Promise<T[]>;
+export declare function readableStreamToAsyncIterator<T>(stream: ReadableStream<T>): AsyncIterable<T>;
+export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;

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

@@ -7,6 +7,7 @@ export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
+export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;

package/lib/esm/agents/agent.d.ts

@@ -19,6 +19,9 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
+export interface AgentCallOptions {
+    streaming?: boolean;
+}
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
     constructor({ inputSchema, outputSchema, ...options }: AgentOptions<I, O>);
     readonly memory?: AgentMemory;
@@ -50,14 +53,38 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     get isCallable(): boolean;
     private checkContextStatus;
     private newDefaultContext;
-    call(input: I | string, context?: Context): Promise<O>;
+    call(input: I | string, context: Context | undefined, options: AgentCallOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions): Promise<AgentResponse<O>>;
+    private processAgentOutput;
+    private processAgentError;
     protected checkUsageAgentCalls(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
-    abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
+    abstract process(input: I, context: Context, options?: AgentCallOptions): AgentProcessResult<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
     [inspect.custom](): string;
 }
+export type AgentResponse<T> = T | AgentResponseStream<T>;
+export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
+export type AgentResponseChunk<T> = AgentResponseDelta<T>;
+export declare function isEmptyChunk<T>(chunk: AgentResponseChunk<T>): boolean;
+export interface AgentResponseDelta<T> {
+    delta: {
+        text?: Partial<{
+            [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
+        }> | {
+            [key: string]: string;
+        };
+        json?: Partial<T>;
+    };
+}
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | undefined | void>;
+export type AgentProcessResult<O extends Message> = Promise<AgentResponse<O>> | AgentProcessAsyncGenerator<O>;
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
@@ -66,6 +93,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context: Context): Promise<TransferAgentOutput | O>;
+    process(input: I, context: Context, options?: AgentCallOptions): Promise<AgentResponse<O | TransferAgentOutput>>;
 }
 export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;

package/lib/esm/agents/agent.js

@@ -2,7 +2,8 @@ import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
-import { checkArguments, createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
+import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
+import { checkArguments, createAccessorArray, isEmpty, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export class Agent {
@@ -94,7 +95,7 @@ export class Agent {
     async newDefaultContext() {
         return import("../execution-engine/context.js").then((m) => new m.ExecutionContext());
     }
-    async call(input, context) {
+    async call(input, context, options) {
         const ctx = context ?? (await this.newDefaultContext());
         const message = typeof input === "string" ? createMessage(input) : input;
         logger.core("Call agent %s started with input: %O", this.name, input);
@@ -104,27 +105,51 @@ export class Agent {
             const parsedInput = checkArguments(`Agent ${this.name} input`, this.inputSchema, message);
             this.preprocess(parsedInput, ctx);
             this.checkContextStatus(ctx);
-            const output = await this.process(parsedInput, ctx)
-                .then((output) => {
-                const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
-                return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
-            })
-                .then((output) => {
-                this.postprocess(parsedInput, output, ctx);
-                return output;
-            });
-            logger.core("Call agent %s succeed with output: %O", this.name, input);
-            if (!this.disableEvents)
-                ctx.emit("agentSucceed", { agent: this, output });
-            return output;
+            const response = await this.process(parsedInput, ctx, options);
+            if (options?.streaming) {
+                const stream = response instanceof ReadableStream
+                    ? response
+                    : isAsyncGenerator(response)
+                        ? asyncGeneratorToReadableStream(response)
+                        : objectToAgentResponseStream(response);
+                return onAgentResponseStreamEnd(stream, async (result) => {
+                    return await this.processAgentOutput(parsedInput, result, ctx);
+                }, {
+                    errorCallback: (error) => {
+                        try {
+                            this.processAgentError(error, ctx);
+                        }
+                        catch (error) {
+                            return error;
+                        }
+                    },
+                });
+            }
+            return await this.processAgentOutput(parsedInput, response instanceof ReadableStream
+                ? await agentResponseStreamToObject(response)
+                : isAsyncGenerator(response)
+                    ? await agentResponseStreamToObject(response)
+                    : response, ctx);
         }
         catch (error) {
-            logger.core("Call agent %s failed with error: %O", this.name, error);
-            if (!this.disableEvents)
-                ctx.emit("agentFailed", { agent: this, error });
-            throw error;
+            this.processAgentError(error, ctx);
         }
     }
+    async processAgentOutput(input, output, context) {
+        const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
+        const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
+        this.postprocess(input, finalOutput, context);
+        logger.core("Call agent %s succeed with output: %O", this.name, finalOutput);
+        if (!this.disableEvents)
+            context.emit("agentSucceed", { agent: this, output: finalOutput });
+        return finalOutput;
+    }
+    processAgentError(error, context) {
+        logger.core("Call agent %s failed with error: %O", this.name, error);
+        if (!this.disableEvents)
+            context.emit("agentFailed", { agent: this, error });
+        throw error;
+    }
     checkUsageAgentCalls(context) {
         const { limits, usage } = context;
         if (limits?.maxAgentCalls && usage.agentCalls >= limits.maxAgentCalls) {
@@ -152,6 +177,9 @@ export class Agent {
         return this.name;
     }
 }
+export function isEmptyChunk(chunk) {
+    return isEmpty(chunk.delta.json) && isEmpty(chunk.delta.text);
+}
 function checkAgentInputOutputSchema(schema) {
     if (!(schema instanceof ZodObject) && typeof schema !== "function") {
         throw new Error("schema must be a zod object or function return a zod object ");
@@ -166,12 +194,12 @@ export class FunctionAgent extends Agent {
         this.fn = options.fn ?? (() => ({}));
     }
     fn;
-    async process(input, context) {
-        const result = await this.fn(input, context);
+    async process(input, context, options) {
+        let result = await this.fn(input, context);
         if (result instanceof Agent) {
-            return transferToAgentOutput(result);
+            result = transferToAgentOutput(result);
         }
-        return result;
+        return options?.streaming ? objectToAgentResponseStream(result) : result;
     }
 }
 function functionToAgent(agent) {

package/lib/esm/agents/ai-agent.d.ts

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { ChatModel } from "../models/chat-model.js";
+import type { ChatModelInput } from "../models/chat-model.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
-import { Agent, type AgentOptions, type Message } from "./agent.js";
+import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
+import { type TransferAgentOutput } from "./types.js";
 export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     model?: ChatModel;
     instructions?: string | PromptBuilder;
@@ -27,35 +29,35 @@ export declare const aiAgentOptionsSchema: z.ZodObject<{
     disableLogging: z.ZodOptional<z.ZodBoolean>;
     memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
 }, "strip", z.ZodTypeAny, {
-    description?: string | undefined;
-    memory?: any;
-    includeInputInOutput?: boolean | undefined;
-    subscribeTopic?: string | string[] | undefined;
-    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
+    description?: string | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
-    disableLogging?: boolean | undefined;
-}, {
-    description?: string | undefined;
-    memory?: any;
     includeInputInOutput?: boolean | undefined;
     subscribeTopic?: string | string[] | undefined;
     publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
+    disableLogging?: boolean | undefined;
+    memory?: any;
+}, {
     tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
     toolChoice?: Agent<Message, Message> | "auto" | "none" | "required" | "router" | undefined;
     name?: string | undefined;
+    description?: string | undefined;
     model?: ChatModel | undefined;
     instructions?: string | PromptBuilder | undefined;
     outputKey?: string | undefined;
     enableHistory?: boolean | undefined;
     maxHistoryMessages?: number | undefined;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
     disableLogging?: boolean | undefined;
+    memory?: any;
 }>;
 export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
@@ -64,5 +66,6 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    process(input: I, context: Context): Promise<import("./types.js").TransferAgentOutput | O>;
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
+    processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
 }

package/lib/esm/agents/ai-agent.js

@@ -2,7 +2,9 @@ import { z } from "zod";
 import { ChatModel } from "../models/chat-model.js";
 import { MESSAGE_KEY, PromptBuilder } from "../prompt/prompt-builder.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
-import { Agent } from "./agent.js";
+import { readableStreamToAsyncIterator } from "../utils/stream-utils.js";
+import { isEmpty } from "../utils/type-utils.js";
+import { Agent, } from "./agent.js";
 import { isTransferAgentOutput } from "./types.js";
 export const aiAgentToolChoiceSchema = z.union([
     z.literal("auto"),
@@ -46,23 +48,35 @@ export class AIAgent extends Agent {
     instructions;
     outputKey;
     toolChoice;
-    async process(input, context) {
+    async *process(input, context) {
         const model = context.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
-        const { toolAgents, messages, ...modelInput } = await this.instructions.build({
+        const { toolAgents, ...modelInput } = await this.instructions.build({
             agent: this,
             input,
             model,
             context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        if (this.toolChoice === "router") {
+            yield* this.processRouter(input, model, modelInput, context, toolsMap);
+            return;
+        }
         const toolCallMessages = [];
+        const outputKey = this.outputKey || MESSAGE_KEY;
         for (;;) {
-            const { text, json, toolCalls } = await context.call(model, {
-                ...modelInput,
-                messages: messages.concat(toolCallMessages),
-            });
+            const modelOutput = {};
+            const stream = await context.call(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            for await (const value of readableStreamToAsyncIterator(stream)) {
+                if (value.delta.text?.text) {
+                    yield { delta: { text: { [outputKey]: value.delta.text.text } } };
+                }
+                if (value.delta.json) {
+                    Object.assign(modelOutput, value.delta.json);
+                }
+            }
+            const { toolCalls, json, text } = modelOutput;
             if (toolCalls?.length) {
                 const executedToolCalls = [];
                 // Execute tools
@@ -81,14 +95,6 @@ export class AIAgent extends Agent {
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
                     toolCallMessages.push(AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()));
-                    // Return the output of the first tool if the toolChoice is "router"
-                    if (this.toolChoice === "router") {
-                        const output = executedToolCalls[0]?.output;
-                        if (!output || executedToolCalls.length !== 1) {
-                            throw new Error("Router toolChoice requires exactly one tool to be executed");
-                        }
-                        return output;
-                    }
                     continue;
                 }
             }
@@ -96,11 +102,24 @@ export class AIAgent extends Agent {
             if (modelInput.responseFormat?.type === "json_schema") {
                 Object.assign(result, json);
             }
-            else {
-                const outputKey = this.outputKey || MESSAGE_KEY;
+            else if (text) {
                 Object.assign(result, { [outputKey]: text });
             }
-            return result;
+            if (!isEmpty(result)) {
+                yield { delta: { json: result } };
+            }
+            return;
+        }
+    }
+    async *processRouter(input, model, modelInput, context, toolsMap) {
+        const { toolCalls: [call] = [], } = await context.call(model, modelInput);
+        if (!call) {
+            throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
+        const tool = toolsMap.get(call.function.name);
+        if (!tool)
+            throw new Error(`Tool not found: ${call.function.name}`);
+        const stream = await context.call(tool, { ...call.function.arguments, ...input }, { streaming: true });
+        yield* readableStreamToAsyncIterator(stream);
     }
 }

package/lib/esm/agents/user-agent.d.ts

@@ -2,7 +2,7 @@ import { ReadableStream } from "node:stream/web";
 import { type Context, type Runnable } from "../execution-engine/context.js";
 import type { MessagePayload } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentOptions, type Message } from "./agent.js";
+import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
@@ -14,8 +14,8 @@ export declare class UserAgent<I extends Message = Message, O extends Message =
     context: Context;
     private _process?;
     private activeAgent?;
-    call(input: string | I, context?: Context): Promise<O>;
-    process(input: I, context: Context): Promise<O>;
+    call: Agent<I, O>["call"];
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];