@aigne/core 1.9.0 → 1.11.0

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

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAgentFromJsFile = loadAgentFromJsFile;
 const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
 const zod_1 = require("zod");
+const camelize_js_1 = require("../utils/camelize.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
 const agentJsFileSchema = zod_1.z.object({
@@ -57,11 +58,9 @@ async function loadAgentFromJsFile(path) {
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return (0, type_utils_js_1.tryOrThrow)(() => agentJsFileSchema.parse({
+    return (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentJsFileSchema.parse({
+        ...agent,
         name: agent.agent_name || agent.name,
-        description: agent.description,
-        input_schema: agent.input_schema,
-        output_schema: agent.output_schema,
         fn: agent,
-    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+    }), { shallowKeys: ["input_schema", "output_schema"] }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
 }

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

@@ -5,6 +5,7 @@ const promises_1 = require("node:fs/promises");
 const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
+const camelize_js_1 = require("../utils/camelize.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
 const agentFileSchema = zod_1.z.discriminatedUnion("type", [
@@ -37,6 +38,15 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
             .union([zod_1.z.literal("auto"), zod_1.z.literal("none"), zod_1.z.literal("required"), zod_1.z.literal("router")])
             .nullish()
             .transform((v) => v ?? undefined),
+        memory: zod_1.z
+            .union([
+            zod_1.z.boolean(),
+            zod_1.z.object({
+                subscribe_topic: zod_1.z.array(zod_1.z.string()),
+            }),
+        ])
+            .nullish()
+            .transform((v) => v || undefined),
     }),
     zod_1.z.object({
         type: zod_1.z.literal("mcp"),
@@ -57,6 +67,8 @@ const agentFileSchema = zod_1.z.discriminatedUnion("type", [
 async function loadAgentFromYamlFile(path) {
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => (0, promises_1.readFile)(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = (0, type_utils_js_1.tryOrThrow)(() => agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    const agent = (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_js_1.customCamelize)(agentFileSchema.parse({ ...json, type: json.type ?? "ai" }), {
+        shallowKeys: ["input_schema", "output_schema"],
+    }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
     return agent;
 }

package/lib/cjs/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/cjs/loader/index.js

@@ -39,26 +39,15 @@ async function load(options) {
 async function loadAgent(path) {
     if ((0, node_path_1.extname)(path) === ".js") {
         const agent = await (0, agent_js_js_1.loadAgentFromJsFile)(path);
-        return agent_js_1.FunctionAgent.from({
-            name: agent.name,
-            description: agent.description,
-            inputSchema: agent.input_schema,
-            outputSchema: agent.output_schema,
-            fn: agent.fn,
-        });
+        return agent_js_1.FunctionAgent.from(agent);
     }
     if ((0, node_path_1.extname)(path) === ".yaml" || (0, node_path_1.extname)(path) === ".yml") {
         const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
         if (agent.type === "ai") {
             return ai_agent_js_1.AIAgent.from({
-                name: agent.name,
-                description: agent.description,
-                instructions: agent.instructions,
-                inputSchema: agent.input_schema,
-                outputSchema: agent.output_schema,
-                outputKey: agent.output_key,
-                tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename)))),
-                toolChoice: agent.tool_choice,
+                ...agent,
+                tools: agent.tools &&
+                    (await Promise.all(agent.tools.map((filename) => loadAgent((0, node_path_1.join)((0, node_path_1.dirname)(path), filename))))),
             });
         }
         if (agent.type === "mcp") {

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/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/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") {