@aigne/core 1.9.0 → 1.10.0

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,37 @@ 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 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 +92,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,6 +2,7 @@ import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
+import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
@@ -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) {
@@ -166,12 +191,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

@@ -2,7 +2,8 @@ import { z } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { ChatModel } 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;
@@ -64,5 +65,5 @@ 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>;
 }

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,7 +48,7 @@ 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");
@@ -58,11 +60,19 @@ export class AIAgent extends Agent {
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         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: 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
@@ -84,7 +94,8 @@ export class AIAgent extends Agent {
                     // 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) {
+                        const { supportsParallelToolCalls } = model.getModelCapabilities();
+                        if (!output || (supportsParallelToolCalls && executedToolCalls.length !== 1)) {
                             throw new Error("Router toolChoice requires exactly one tool to be executed");
                         }
                         return output;
@@ -96,11 +107,13 @@ 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;
         }
     }
 }

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"];

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

@@ -1,7 +1,8 @@
 import { ReadableStream } from "node:stream/web";
 import { createPublishMessage } from "../execution-engine/context.js";
+import { readableStreamToAsyncIterator } from "../utils/stream-utils.js";
 import { orArrayToArray } from "../utils/type-utils.js";
-import { Agent } from "./agent.js";
+import { Agent, } from "./agent.js";
 export class UserAgent extends Agent {
     static from(options) {
         return new UserAgent(options);
@@ -15,26 +16,31 @@ export class UserAgent extends Agent {
     context;
     _process;
     activeAgent;
-    call(input, context) {
+    call = ((input, context, options) => {
         if (!context)
             this.context = this.context.newContext({ reset: true });
-        return super.call(input, context ?? this.context);
-    }
-    async process(input, context) {
+        return super.call(input, context ?? this.context, options);
+    });
+    async *process(input, context) {
         if (this._process) {
-            return this._process(input, context);
+            yield { delta: { json: await this._process(input, context) } };
+            return;
         }
         if (this.activeAgent) {
             const [output, agent] = await context.call(this.activeAgent, input, {
                 returnActiveAgent: true,
+                streaming: true,
+            });
+            agent.then((agent) => {
+                this.activeAgent = agent;
             });
-            this.activeAgent = agent;
-            return output;
+            yield* readableStreamToAsyncIterator(output);
+            return;
         }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
             context.publish(publicTopic, createPublishMessage(input, this));
-            return {};
+            return;
         }
         throw new Error("UserAgent must have a process function or a publishTopic");
     }

package/lib/esm/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/esm/execution-engine/context.js

@@ -1,11 +1,12 @@
 import EventEmitter from "node:events";
 import { v7 } from "uuid";
 import { z } from "zod";
-import { Agent } from "../agents/agent.js";
+import { Agent, } from "../agents/agent.js";
 import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
 import { createMessage } from "../prompt/prompt-builder.js";
-import { checkArguments, isNil, } from "../utils/type-utils.js";
+import { agentResponseStreamToObject, asyncGeneratorToReadableStream, onAgentResponseStreamEnd, readableStreamToAsyncIterator, } from "../utils/stream-utils.js";
+import { checkArguments, isNil, omitBy, } from "../utils/type-utils.js";
 import { MessageQueue, } from "./message-queue.js";
 import { newEmptyContextUsage } from "./usage.js";
 export function createPublishMessage(message, from) {
@@ -62,23 +63,49 @@ export class ExecutionContext {
         }
         const newContext = this.newContext();
         const msg = createMessage(message);
-        return newContext.internal
-            .call(agent, msg, newContext, options)
-            .then(async ({ output, agent: activeAgent }) => {
-            if (activeAgent instanceof Agent) {
-                const publishTopics = typeof activeAgent.publishTopic === "function"
-                    ? await activeAgent.publishTopic(output)
-                    : activeAgent.publishTopic;
-                if (publishTopics?.length) {
-                    newContext.publish(publishTopics, createPublishMessage(output, activeAgent));
+        return Promise.resolve(newContext.internal.call(agent, msg, newContext, options)).then(async (response) => {
+            if (!options?.streaming) {
+                const { __activeAgent__: activeAgent, ...output } = await agentResponseStreamToObject(response);
+                this.onCallSuccess(activeAgent, output, newContext);
+                if (options?.returnActiveAgent) {
+                    return [output, activeAgent];
                 }
+                return output;
             }
-            if (options?.returnActiveAgent) {
-                return [output, activeAgent];
+            const activeAgentPromise = Promise.withResolvers();
+            const stream = onAgentResponseStreamEnd(asyncGeneratorToReadableStream(response), async ({ __activeAgent__: activeAgent, ...output }) => {
+                this.onCallSuccess(activeAgent, output, newContext);
+                activeAgentPromise.resolve(activeAgent);
+            }, {
+                processChunk(chunk) {
+                    if (chunk.delta.json) {
+                        return {
+                            ...chunk,
+                            delta: {
+                                ...chunk.delta,
+                                json: omitBy(chunk.delta.json, (_, k) => k === "__activeAgent__"),
+                            },
+                        };
+                    }
+                    return chunk;
+                },
+            });
+            if (options.returnActiveAgent) {
+                return [stream, activeAgentPromise.promise];
             }
-            return output;
+            return stream;
         });
     });
+    async onCallSuccess(activeAgent, output, context) {
+        if (activeAgent instanceof Agent) {
+            const publishTopics = typeof activeAgent.publishTopic === "function"
+                ? await activeAgent.publishTopic(output)
+                : activeAgent.publishTopic;
+            if (publishTopics?.length) {
+                context.publish(publishTopics, createPublishMessage(output, activeAgent));
+            }
+        }
+    }
     publish = ((topic, payload) => {
         return this.internal.messageQueue.publish(topic, { ...payload, context: this });
     });
@@ -144,11 +171,11 @@ class ExecutionContextInternal {
     get status() {
         return this.abortController.signal.aborted ? "timeout" : "normal";
     }
-    async call(agent, input, context, options) {
+    call(agent, input, context, options) {
         this.initTimeout();
         return withAbortSignal(this.abortController.signal, new Error("ExecutionContext is timeout"), () => this.callAgent(agent, input, context, options));
     }
-    async callAgent(agent, input, context, options) {
+    async *callAgent(agent, input, context, options) {
         let activeAgent = agent;
         let output;
         for (;;) {
@@ -157,7 +184,16 @@ class ExecutionContextInternal {
                 result = await activeAgent(input, context);
             }
             else {
-                result = await activeAgent.call(input, context);
+                result = {};
+                const stream = await activeAgent.call(input, context, { streaming: true });
+                for await (const value of readableStreamToAsyncIterator(stream)) {
+                    if (value.delta.text) {
+                        yield { delta: { text: value.delta.text } };
+                    }
+                    if (value.delta.json) {
+                        Object.assign(result, value.delta.json);
+                    }
+                }
             }
             if (result instanceof Agent) {
                 activeAgent = result;
@@ -177,22 +213,34 @@ class ExecutionContextInternal {
         }
         if (!output)
             throw new Error("Unexpected empty output");
-        return {
-            agent: activeAgent,
-            output,
+        yield {
+            delta: {
+                json: {
+                    ...output,
+                    __activeAgent__: activeAgent,
+                },
+            },
         };
     }
 }
-function withAbortSignal(signal, error, fn) {
-    return new Promise((resolve, reject) => {
-        const listener = () => reject(error);
-        signal.addEventListener("abort", listener);
-        fn()
-            .then(resolve, reject)
-            .finally(() => {
-            signal.removeEventListener("abort", listener);
-        });
-    });
+async function* withAbortSignal(signal, error, fn) {
+    const iterator = fn();
+    const timeoutPromise = Promise.withResolvers();
+    const listener = () => {
+        timeoutPromise.reject(error);
+    };
+    signal.addEventListener("abort", listener);
+    try {
+        for (;;) {
+            const next = await Promise.race([iterator.next(), timeoutPromise.promise]);
+            if (next.done)
+                break;
+            yield next.value;
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", listener);
+    }
 }
 const executionContextCallArgsSchema = z.object({
     agent: z.union([z.function(), z.instanceof(Agent)]),

package/lib/esm/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/esm/models/chat-model.js

@@ -7,6 +7,12 @@ export class ChatModel extends Agent {
             outputSchema: chatModelOutputSchema,
         });
     }
+    supportsParallelToolCalls = true;
+    getModelCapabilities() {
+        return {
+            supportsParallelToolCalls: this.supportsParallelToolCalls,
+        };
+    }
     preprocess(input, context) {
         super.preprocess(input, context);
         const { limits, usage } = context;

package/lib/esm/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/esm/models/open-router-chat-model.js

@@ -10,4 +10,5 @@ export class OpenRouterChatModel extends OpenAIChatModel {
         });
     }
     apiKeyEnvName = "OPEN_ROUTER_API_KEY";
+    supportsParallelToolCalls = false;
 }

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