@aigne/core 1.10.0 → 1.11.0

package/lib/cjs/models/claude-chat-model.js

@@ -7,8 +7,8 @@ exports.ClaudeChatModel = exports.claudeChatModelOptionsSchema = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const zod_1 = require("zod");
 const json_schema_js_1 = require("../utils/json-schema.js");
-const logger_js_1 = require("../utils/logger.js");
 const model_utils_js_1 = require("../utils/model-utils.js");
+const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
@@ -45,7 +45,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input) {
+    async process(input, _context, options) {
         const model = this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
         const disableParallelToolUse = input.modelOptions?.parallelToolCalls === false ||
             this.modelOptions?.parallelToolCalls === false;
@@ -62,6 +62,9 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             ...body,
             stream: true,
         });
+        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+            return this.extractResultFromClaudeStream(stream, true);
+        }
         const result = await this.extractResultFromClaudeStream(stream);
         // Claude doesn't support json_schema response and tool calls in the same request,
         // so we need to make a separate request for json_schema response when the tool calls is empty
@@ -75,67 +78,79 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
         }
         return result;
     }
-    async extractResultFromClaudeStream(stream) {
+    async extractResultFromClaudeStream(stream, streaming) {
         const logs = [];
-        try {
-            let text = "";
-            const toolCalls = [];
-            let usage;
-            let model;
-            for await (const chunk of stream) {
-                if (chunk.type === "message_start") {
-                    model ??= chunk.message.model;
-                    const { input_tokens, output_tokens } = chunk.message.usage;
-                    usage = {
-                        inputTokens: input_tokens,
-                        outputTokens: output_tokens,
-                    };
-                }
-                if (chunk.type === "message_delta" && usage) {
-                    usage.outputTokens = chunk.usage.output_tokens;
-                }
-                logs.push(JSON.stringify(chunk));
-                // handle streaming text
-                if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                    text += chunk.delta.text;
+        const result = new ReadableStream({
+            async start(controller) {
+                try {
+                    const toolCalls = [];
+                    let usage;
+                    let model;
+                    for await (const chunk of stream) {
+                        if (chunk.type === "message_start") {
+                            if (!model) {
+                                model = chunk.message.model;
+                                controller.enqueue({ delta: { json: { model } } });
+                            }
+                            const { input_tokens, output_tokens } = chunk.message.usage;
+                            usage = {
+                                inputTokens: input_tokens,
+                                outputTokens: output_tokens,
+                            };
+                        }
+                        if (chunk.type === "message_delta" && usage) {
+                            usage.outputTokens = chunk.usage.output_tokens;
+                        }
+                        logs.push(JSON.stringify(chunk));
+                        // handle streaming text
+                        if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                            controller.enqueue({ delta: { text: { text: chunk.delta.text } } });
+                        }
+                        if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                            toolCalls[chunk.index] = {
+                                type: "function",
+                                id: chunk.content_block.id,
+                                function: {
+                                    name: chunk.content_block.name,
+                                    arguments: {},
+                                },
+                                args: "",
+                            };
+                        }
+                        if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                            const call = toolCalls[chunk.index];
+                            if (!call)
+                                throw new Error("Tool call not found");
+                            call.args += chunk.delta.partial_json;
+                        }
+                    }
+                    controller.enqueue({ delta: { json: { usage } } });
+                    if (toolCalls.length) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    toolCalls: toolCalls
+                                        .map(({ args, ...c }) => ({
+                                        ...c,
+                                        function: {
+                                            ...c.function,
+                                            // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
+                                            arguments: args.trim() ? (0, json_schema_js_1.parseJSON)(args) : {},
+                                        },
+                                    }))
+                                        .filter(type_utils_js_1.isNonNullable),
+                                },
+                            },
+                        });
+                    }
+                    controller.close();
                 }
-                if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
-                    toolCalls[chunk.index] = {
-                        type: "function",
-                        id: chunk.content_block.id,
-                        function: {
-                            name: chunk.content_block.name,
-                            arguments: {},
-                        },
-                        args: "",
-                    };
+                catch (error) {
+                    controller.error(error);
                 }
-                if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
-                    const call = toolCalls[chunk.index];
-                    if (!call)
-                        throw new Error("Tool call not found");
-                    call.args += chunk.delta.partial_json;
-                }
-            }
-            const result = { usage, model, text };
-            if (toolCalls.length) {
-                result.toolCalls = toolCalls
-                    .map(({ args, ...c }) => ({
-                    ...c,
-                    function: {
-                        ...c.function,
-                        // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
-                        arguments: args.trim() ? (0, json_schema_js_1.parseJSON)(args) : {},
-                    },
-                }))
-                    .filter(type_utils_js_1.isNonNullable);
-            }
-            return result;
-        }
-        catch (error) {
-            logger_js_1.logger.core("Failed to process Claude stream", { error, logs });
-            throw error;
-        }
+            },
+        });
+        return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(result);
     }
     async requestStructuredOutput(body, responseFormat) {
         if (responseFormat?.type !== "json_schema") {

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

@@ -333,13 +333,11 @@ async function extractResultFromStream(stream, jsonMode, streaming) {
                         },
                     });
                 }
+                controller.close();
             }
             catch (error) {
                 controller.error(error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
     return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(result);

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

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

package/lib/cjs/utils/camelize.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customCamelize = customCamelize;
+const camelize_ts_1 = __importDefault(require("camelize-ts"));
+function customCamelize(obj, { shallowKeys = [] } = {}) {
+    const shallow = Object.fromEntries(shallowKeys?.filter((key) => key in obj).map((key) => [key, obj[key]]) ?? []);
+    const deep = Object.fromEntries(Object.entries(obj).filter(([key]) => !shallowKeys?.includes(key)));
+    return {
+        ...(0, camelize_ts_1.default)(shallow, true),
+        ...(0, camelize_ts_1.default)(deep),
+    };
+}
+const _unique = Symbol();

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

@@ -1,4 +1,5 @@
-import type { AgentProcessAsyncGenerator, AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { MESSAGE_KEY } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "./type-utils.js";
 export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
 export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
@@ -13,3 +14,4 @@ export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chu
 export declare function arrayToAgentResponseStream<T>(chunks: (AgentResponseChunk<T> | Error)[]): AgentResponseStream<T>;
 export declare function readableStreamToArray<T>(stream: ReadableStream<T>): Promise<T[]>;
 export declare function readableStreamToAsyncIterator<T>(stream: ReadableStream<T>): AsyncIterable<T>;
+export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;

package/lib/cjs/utils/stream-utils.js

@@ -13,7 +13,9 @@ exports.arrayToAgentProcessAsyncGenerator = arrayToAgentProcessAsyncGenerator;
 exports.arrayToAgentResponseStream = arrayToAgentResponseStream;
 exports.readableStreamToArray = readableStreamToArray;
 exports.readableStreamToAsyncIterator = readableStreamToAsyncIterator;
+exports.stringToAgentResponseStream = stringToAgentResponseStream;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
 function objectToAgentResponseStream(json) {
     return new ReadableStream({
@@ -78,13 +80,11 @@ function asyncGeneratorToReadableStream(generator) {
                     if (chunk.done)
                         break;
                 }
+                controller.close();
             }
             catch (error) {
                 controller.error(error);
             }
-            finally {
-                controller.close();
-            }
         },
     });
 }
@@ -95,7 +95,8 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                 const json = {};
                 for await (const value of readableStreamToAsyncIterator(stream)) {
                     const chunk = options?.processChunk ? options.processChunk(value) : value;
-                    controller.enqueue(chunk);
+                    if (!(0, agent_js_1.isEmptyChunk)(chunk))
+                        controller.enqueue(chunk);
                     mergeAgentResponseChunk(json, value);
                 }
                 const result = await callback(json);
@@ -157,3 +158,8 @@ async function* readableStreamToAsyncIterator(stream) {
         yield value;
     }
 }
+function stringToAgentResponseStream(str, key = "text") {
+    const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+    const segments = segmenter.segment(str);
+    return arrayToAgentResponseStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
+}

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

@@ -72,6 +72,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
 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<{

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

@@ -1,6 +1,7 @@
 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 AgentProcessAsyncGenerator, type Message } from "./agent.js";
 import { type TransferAgentOutput } from "./types.js";
@@ -28,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>;
@@ -66,4 +67,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
     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/dts/loader/agent-js.d.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,5 @@
-import type { AgentProcessAsyncGenerator, AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+import { type AgentProcessAsyncGenerator, type AgentResponseChunk, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { MESSAGE_KEY } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "./type-utils.js";
 export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
 export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
@@ -13,3 +14,4 @@ export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chu
 export declare function arrayToAgentResponseStream<T>(chunks: (AgentResponseChunk<T> | Error)[]): AgentResponseStream<T>;
 export declare function readableStreamToArray<T>(stream: ReadableStream<T>): Promise<T[]>;
 export declare function readableStreamToAsyncIterator<T>(stream: ReadableStream<T>): AsyncIterable<T>;
+export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;

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

@@ -72,6 +72,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
 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<{

package/lib/esm/agents/agent.js

@@ -3,7 +3,7 @@ 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 { checkArguments, createAccessorArray, isEmpty, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export class Agent {
@@ -177,6 +177,9 @@ export class Agent {
         return this.name;
     }
 }
+export function isEmptyChunk(chunk) {
+    return isEmpty(chunk.delta.json) && isEmpty(chunk.delta.text);
+}
 function checkAgentInputOutputSchema(schema) {
     if (!(schema instanceof ZodObject) && typeof schema !== "function") {
         throw new Error("schema must be a zod object or function return a zod object ");

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

@@ -1,6 +1,7 @@
 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 AgentProcessAsyncGenerator, type Message } from "./agent.js";
 import { type TransferAgentOutput } from "./types.js";
@@ -28,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>;
@@ -66,4 +67,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
     process(input: I, context: Context): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
+    processRouter(input: I, model: ChatModel, modelInput: ChatModelInput, context: Context, toolsMap: Map<string, Agent>): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
 }

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

@@ -52,18 +52,22 @@ export class AIAgent extends Agent {
         const model = context.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
-        const { toolAgents, messages, ...modelInput } = await this.instructions.build({
+        const { toolAgents, ...modelInput } = await this.instructions.build({
             agent: this,
             input,
             model,
             context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        if (this.toolChoice === "router") {
+            yield* this.processRouter(input, model, modelInput, context, toolsMap);
+            return;
+        }
         const toolCallMessages = [];
         const outputKey = this.outputKey || MESSAGE_KEY;
         for (;;) {
             const modelOutput = {};
-            const stream = await context.call(model, { ...modelInput, messages: messages.concat(toolCallMessages) }, { streaming: true });
+            const stream = await context.call(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
             for await (const value of readableStreamToAsyncIterator(stream)) {
                 if (value.delta.text?.text) {
                     yield { delta: { text: { [outputKey]: value.delta.text.text } } };
@@ -91,15 +95,6 @@ export class AIAgent extends Agent {
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
                     toolCallMessages.push(AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()));
-                    // Return the output of the first tool if the toolChoice is "router"
-                    if (this.toolChoice === "router") {
-                        const output = executedToolCalls[0]?.output;
-                        const { supportsParallelToolCalls } = model.getModelCapabilities();
-                        if (!output || (supportsParallelToolCalls && executedToolCalls.length !== 1)) {
-                            throw new Error("Router toolChoice requires exactly one tool to be executed");
-                        }
-                        return output;
-                    }
                     continue;
                 }
             }
@@ -116,4 +111,15 @@ export class AIAgent extends Agent {
             return;
         }
     }
+    async *processRouter(input, model, modelInput, context, toolsMap) {
+        const { toolCalls: [call] = [], } = await context.call(model, modelInput);
+        if (!call) {
+            throw new Error("Router toolChoice requires exactly one tool to be executed");
+        }
+        const tool = toolsMap.get(call.function.name);
+        if (!tool)
+            throw new Error(`Tool not found: ${call.function.name}`);
+        const stream = await context.call(tool, { ...call.function.arguments, ...input }, { streaming: true });
+        yield* readableStreamToAsyncIterator(stream);
+    }
 }

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

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