@aigne/core 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -22,6 +22,18 @@
 * rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
 * use text resource from MCP correctly ([8b9eba8](https://github.com/AIGNE-io/aigne-framework/commit/8b9eba83352ec096a2a5d4f410d4c4bde7420bce))
 
+## [1.10.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.9.0...core-v1.10.0) (2025-04-22)
+
+
+### Features
+
+* **stream:** add streaming output support for agent ([#73](https://github.com/AIGNE-io/aigne-framework/issues/73)) ([5f3ea4b](https://github.com/AIGNE-io/aigne-framework/commit/5f3ea4bccda7c8c457d6e9518b3d6a8b254ec041))
+
+
+### Bug Fixes
+
+* **core:** support dynamic model capability detection ([#72](https://github.com/AIGNE-io/aigne-framework/issues/72)) ([9d56d98](https://github.com/AIGNE-io/aigne-framework/commit/9d56d9885778962e5bef806445ad8c4d199f2c65))
+
 ## [1.9.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.8.0...core-v1.9.0) (2025-04-20)
 
 

package/lib/cjs/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/cjs/agents/agent.js

@@ -38,6 +38,7 @@ const node_util_1 = require("node:util");
 const zod_1 = require("zod");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const logger_js_1 = require("../utils/logger.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const memory_js_1 = require("./memory.js");
 const types_js_1 = require("./types.js");
@@ -130,7 +131,7 @@ class Agent {
     async newDefaultContext() {
         return Promise.resolve().then(() => __importStar(require("../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" ? (0, prompt_builder_js_1.createMessage)(input) : input;
         logger_js_1.logger.core("Call agent %s started with input: %O", this.name, input);
@@ -140,27 +141,51 @@ class Agent {
             const parsedInput = (0, type_utils_js_1.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 = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
-                return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
-            })
-                .then((output) => {
-                this.postprocess(parsedInput, output, ctx);
-                return output;
-            });
-            logger_js_1.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
+                    : (0, stream_utils_js_1.isAsyncGenerator)(response)
+                        ? (0, stream_utils_js_1.asyncGeneratorToReadableStream)(response)
+                        : (0, stream_utils_js_1.objectToAgentResponseStream)(response);
+                return (0, stream_utils_js_1.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 (0, stream_utils_js_1.agentResponseStreamToObject)(response)
+                : (0, stream_utils_js_1.isAsyncGenerator)(response)
+                    ? await (0, stream_utils_js_1.agentResponseStreamToObject)(response)
+                    : response, ctx);
         }
         catch (error) {
-            logger_js_1.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 = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
+        const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
+        this.postprocess(input, finalOutput, context);
+        logger_js_1.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_js_1.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) {
@@ -203,12 +228,12 @@ 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 (0, types_js_1.transferToAgentOutput)(result);
+            result = (0, types_js_1.transferToAgentOutput)(result);
         }
-        return result;
+        return options?.streaming ? (0, stream_utils_js_1.objectToAgentResponseStream)(result) : result;
     }
 }
 exports.FunctionAgent = FunctionAgent;

package/lib/cjs/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/cjs/agents/ai-agent.js

@@ -5,6 +5,8 @@ const zod_1 = require("zod");
 const chat_model_js_1 = require("../models/chat-model.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const template_js_1 = require("../prompt/template.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 const types_js_1 = require("./types.js");
 exports.aiAgentToolChoiceSchema = zod_1.z.union([
@@ -49,7 +51,7 @@ class AIAgent extends agent_js_1.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");
@@ -61,11 +63,19 @@ class AIAgent extends agent_js_1.Agent {
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         const toolCallMessages = [];
+        const outputKey = this.outputKey || prompt_builder_js_1.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 (0, stream_utils_js_1.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
@@ -87,7 +97,8 @@ class AIAgent extends agent_js_1.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;
@@ -99,11 +110,13 @@ class AIAgent extends agent_js_1.Agent {
             if (modelInput.responseFormat?.type === "json_schema") {
                 Object.assign(result, json);
             }
-            else {
-                const outputKey = this.outputKey || prompt_builder_js_1.MESSAGE_KEY;
+            else if (text) {
                 Object.assign(result, { [outputKey]: text });
             }
-            return result;
+            if (!(0, type_utils_js_1.isEmpty)(result)) {
+                yield { delta: { json: result } };
+            }
+            return;
         }
     }
 }

package/lib/cjs/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/cjs/agents/user-agent.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserAgent = void 0;
 const web_1 = require("node:stream/web");
 const context_js_1 = require("../execution-engine/context.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 class UserAgent extends agent_js_1.Agent {
@@ -18,26 +19,31 @@ class UserAgent extends agent_js_1.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* (0, stream_utils_js_1.readableStreamToAsyncIterator)(output);
+            return;
         }
         const publicTopic = typeof this.publishTopic === "function" ? await this.publishTopic(input) : this.publishTopic;
         if (publicTopic?.length) {
             context.publish(publicTopic, (0, context_js_1.createPublishMessage)(input, this));
-            return {};
+            return;
         }
         throw new Error("UserAgent must have a process function or a publishTopic");
     }

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

@@ -12,6 +12,7 @@ const agent_js_1 = require("../agents/agent.js");
 const types_js_1 = require("../agents/types.js");
 const user_agent_js_1 = require("../agents/user-agent.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const message_queue_js_1 = require("./message-queue.js");
 const usage_js_1 = require("./usage.js");
@@ -69,23 +70,49 @@ class ExecutionContext {
         }
         const newContext = this.newContext();
         const msg = (0, prompt_builder_js_1.createMessage)(message);
-        return newContext.internal
-            .call(agent, msg, newContext, options)
-            .then(async ({ output, agent: activeAgent }) => {
-            if (activeAgent instanceof agent_js_1.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 (0, stream_utils_js_1.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 = (0, stream_utils_js_1.onAgentResponseStreamEnd)((0, stream_utils_js_1.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: (0, type_utils_js_1.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_js_1.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 });
     });
@@ -152,11 +179,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 (;;) {
@@ -165,7 +192,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 (0, stream_utils_js_1.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_js_1.Agent) {
                 activeAgent = result;
@@ -185,22 +221,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 = zod_1.z.object({
     agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),

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

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

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

@@ -13,5 +13,6 @@ class OpenRouterChatModel extends openai_chat_model_js_1.OpenAIChatModel {
         });
     }
     apiKeyEnvName = "OPEN_ROUTER_API_KEY";
+    supportsParallelToolCalls = false;
 }
 exports.OpenRouterChatModel = OpenRouterChatModel;

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