@aigne/core 1.9.0 → 1.11.0

package/CHANGELOG.md

@@ -22,6 +22,31 @@
 * 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.11.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.10.0...core-v1.11.0) (2025-04-23)
+
+
+### Features
+
+* **core:** enhance ClaudeChatModel to support streaming responses ([#85](https://github.com/AIGNE-io/aigne-framework/issues/85)) ([5433240](https://github.com/AIGNE-io/aigne-framework/commit/5433240e7b663ec9e9f4a79dffa05038088d54fc))
+* support set memory in agent yaml ([#90](https://github.com/AIGNE-io/aigne-framework/issues/90)) ([215118f](https://github.com/AIGNE-io/aigne-framework/commit/215118f1dc55f02322d59a3f18395a459198e031))
+
+
+### Bug Fixes
+
+* **core:** router model should support streaming response ([#88](https://github.com/AIGNE-io/aigne-framework/issues/88)) ([4fb4d92](https://github.com/AIGNE-io/aigne-framework/commit/4fb4d92f8b36011437efba3265591b2477f2d680))
+
+## [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/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,89 @@
+# @aigne/core
+
+[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![NPM Version](https://img.shields.io/npm/v/@aigne/core)](https://www.npmjs.com/package/@aigne/core)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/core)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE)
+
+**English** | [中文](README.zh.md)
+
+Core library of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework) for building AI-powered applications.
+
+## Introduction
+
+`@aigne/core` is the foundation component of [AIGNE Framework](https://github.com/AIGNE-io/aigne-framework), providing the essential modules and tools needed to build AI-driven applications. This package implements the core functionalities of the framework, including agent systems, execution engines, model integrations, and workflow pattern support.
+
+## Features
+
+- **Multiple AI Model Support**: Built-in support for OpenAI, Gemini, Claude, and other mainstream AI models, easily extensible to support additional models
+- **Agent System**: Powerful agent abstractions supporting AI agents, function agents, MCP agents, and more
+- **Execution Engine**: Flexible execution engine handling communication between agents and workflow execution
+- **Workflow Patterns**: Support for sequential, concurrent, routing, handoff, and other workflow patterns
+- **MCP Protocol Integration**: Seamless integration with external systems through the Model Context Protocol
+- **TypeScript Support**: Comprehensive type definitions providing an excellent development experience
+
+## Installation
+
+```bash
+# Using npm
+npm install @aigne/core
+
+# Using yarn
+yarn add @aigne/core
+
+# Using pnpm
+pnpm add @aigne/core
+```
+
+## Basic Usage
+
+```typescript
+import { AIAgent, ExecutionEngine } from "@aigne/core";
+import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
+
+// Create AI model instance
+const model = new OpenAIChatModel({
+  apiKey: process.env.OPENAI_API_KEY,
+  model: process.env.DEFAULT_CHAT_MODEL || "gpt-4-turbo",
+});
+
+// Create AI agent
+const agent = AIAgent.from({
+  name: "Assistant",
+  instructions: "You are a helpful assistant.",
+});
+
+// Create execution engine
+const engine = new ExecutionEngine({ model });
+
+// Use the execution engine to call the agent
+const userAgent = await engine.call(agent);
+
+// Send a message to the agent
+const response = await userAgent.call("Hello, can you help me write a short article?");
+console.log(response);
+```
+
+## Module Structure
+
+- `agents/`: Agent implementations, including AI agents, function agents, MCP agents, etc.
+- `execution-engine/`: Execution engine implementation
+- `loader/`: Loader-related functionality
+- `models/`: Integration with various AI models
+- `prompt/`: Prompt handling functionality
+- `utils/`: Utility functions and helper methods
+
+## Documentation
+
+For more detailed API documentation, please refer to:
+
+- [Agent API](../../docs/apis/agent-api.md)
+- [AI Agent API](../../docs/apis/ai-agent-api.md)
+- [Function Agent API](../../docs/apis/function-agent-api.md)
+- [MCP Agent API](../../docs/apis/mcp-agent-api.md)
+- [Execution Engine API](../../docs/apis/execution-engine-api.md)
+
+## License
+
+Elastic-2.0

package/README.zh.md

@@ -0,0 +1,89 @@
+# @aigne/core
+
+[![GitHub star chart](https://img.shields.io/github/stars/AIGNE-io/aigne-framework?style=flat-square)](https://star-history.com/#AIGNE-io/aigne-framework)
+[![Open Issues](https://img.shields.io/github/issues-raw/AIGNE-io/aigne-framework?style=flat-square)](https://github.com/AIGNE-io/aigne-framework/issues)
+[![codecov](https://codecov.io/gh/AIGNE-io/aigne-framework/graph/badge.svg?token=DO07834RQL)](https://codecov.io/gh/AIGNE-io/aigne-framework)
+[![NPM Version](https://img.shields.io/npm/v/@aigne/core)](https://www.npmjs.com/package/@aigne/core)
+[![Elastic-2.0 licensed](https://img.shields.io/npm/l/@aigne/core)](https://github.com/AIGNE-io/aigne-framework/blob/main/LICENSE)
+
+[English](README.md) | **中文**
+
+[AIGNE 框架](https://github.com/AIGNE-io/aigne-framework)的核心库，用于构建 AI 驱动的应用程序。
+
+## 简介
+
+`@aigne/core` 是 [AIGNE 框架](https://github.com/AIGNE-io/aigne-framework)的基础核心组件，提供了构建 AI 驱动应用程序所需的基本模块和工具。该包实现了框架的核心功能，包括代理系统、执行引擎、模型集成以及工作流模式支持等。
+
+## 特性
+
+- **多种 AI 模型支持**：内置支持 OpenAI、Gemini、Claude 等主流 AI 模型，可轻松扩展支持其他模型
+- **代理系统**：强大的代理抽象，支持 AI 代理、函数代理、MCP 代理等多种类型
+- **执行引擎**：灵活的执行引擎，处理代理之间的通信和工作流执行
+- **工作流模式**：支持顺序、并发、路由、交接等多种工作流模式
+- **MCP 协议集成**：通过模型上下文协议（Model Context Protocol）实现与外部系统的无缝集成
+- **TypeScript 支持**：完善的类型定义，提供良好的开发体验
+
+## 安装
+
+```bash
+# 使用 npm
+npm install @aigne/core
+
+# 使用 yarn
+yarn add @aigne/core
+
+# 使用 pnpm
+pnpm add @aigne/core
+```
+
+## 基本用法
+
+```typescript
+import { AIAgent, ExecutionEngine } from "@aigne/core";
+import { OpenAIChatModel } from "@aigne/core/models/openai-chat-model.js";
+
+// 创建 AI 模型实例
+const model = new OpenAIChatModel({
+  apiKey: process.env.OPENAI_API_KEY,
+  model: process.env.DEFAULT_CHAT_MODEL || "gpt-4-turbo",
+});
+
+// 创建 AI 代理
+const agent = AIAgent.from({
+  name: "助手",
+  instructions: "你是一个有帮助的助手。",
+});
+
+// 创建执行引擎
+const engine = new ExecutionEngine({ model });
+
+// 使用执行引擎调用代理
+const userAgent = await engine.call(agent);
+
+// 向代理发送消息
+const response = await userAgent.call("你好，能帮我写一篇短文吗？");
+console.log(response);
+```
+
+## 模块结构
+
+- `agents/`: 代理相关的实现，包括 AI 代理、函数代理、MCP 代理等
+- `execution-engine/`: 执行引擎的实现
+- `loader/`: 加载器相关功能
+- `models/`: 各种 AI 模型的集成
+- `prompt/`: 提示词处理相关功能
+- `utils/`: 工具函数和辅助方法
+
+## 文档
+
+更多详细的 API 文档，请参考：
+
+- [Agent API](../../docs/apis/agent-api.zh.md)
+- [AI Agent API](../../docs/apis/ai-agent-api.zh.md)
+- [Function Agent API](../../docs/apis/function-agent-api.zh.md)
+- [MCP Agent API](../../docs/apis/mcp-agent-api.zh.md)
+- [Execution Engine API](../../docs/apis/execution-engine-api.zh.md)
+
+## 协议
+
+Elastic-2.0

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

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionAgent = exports.Agent = void 0;
+exports.isEmptyChunk = isEmptyChunk;
 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 +132,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 +142,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) {
@@ -189,6 +215,9 @@ class Agent {
     }
 }
 exports.Agent = Agent;
+function isEmptyChunk(chunk) {
+    return (0, type_utils_js_1.isEmpty)(chunk.delta.json) && (0, type_utils_js_1.isEmpty)(chunk.delta.text);
+}
 function checkAgentInputOutputSchema(schema) {
     if (!(schema instanceof zod_1.ZodObject) && typeof schema !== "function") {
         throw new Error("schema must be a zod object or function return a zod object ");
@@ -203,12 +232,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

@@ -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/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,23 +51,35 @@ 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");
-        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 || 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: modelInput.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
@@ -84,14 +98,6 @@ class AIAgent extends agent_js_1.Agent {
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
                     toolCallMessages.push(template_js_1.AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => template_js_1.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;
                 }
             }
@@ -99,12 +105,25 @@ 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;
+        }
+    }
+    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* (0, stream_utils_js_1.readableStreamToAsyncIterator)(stream);
     }
 }
 exports.AIAgent = AIAgent;

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