@aigne/core 1.9.0 → 1.11.0

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

@@ -1,8 +1,8 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { z } from "zod";
 import { parseJSON } from "../utils/json-schema.js";
-import { logger } from "../utils/logger.js";
 import { mergeUsage } from "../utils/model-utils.js";
+import { agentResponseStreamToObject } from "../utils/stream-utils.js";
 import { checkArguments, isEmpty, isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
@@ -39,7 +39,7 @@ export class ClaudeChatModel extends 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;
@@ -56,6 +56,9 @@ export class ClaudeChatModel extends 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
@@ -69,67 +72,79 @@ export class ClaudeChatModel extends 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() ? parseJSON(args) : {},
+                                        },
+                                    }))
+                                        .filter(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() ? parseJSON(args) : {},
-                    },
-                }))
-                    .filter(isNonNullable);
-            }
-            return result;
-        }
-        catch (error) {
-            logger.core("Failed to process Claude stream", { error, logs });
-            throw error;
-        }
+            },
+        });
+        return streaming ? result : await agentResponseStreamToObject(result);
     }
     async requestStructuredOutput(body, responseFormat) {
         if (responseFormat?.type !== "json_schema") {

package/lib/esm/models/open-router-chat-model.d.ts

@@ -2,4 +2,5 @@ import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-mode
 export declare class OpenRouterChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;
+    protected supportsParallelToolCalls: boolean;
 }

package/lib/esm/models/open-router-chat-model.js

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

package/lib/esm/models/openai-chat-model.d.ts

@@ -1,8 +1,17 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
-import type { Stream } from "openai/streaming.js";
 import { z } from "zod";
+import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
 import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
+export interface OpenAIChatModelCapabilities {
+    supportsNativeStructuredOutputs: boolean;
+    supportsEndWithSystemMessage: boolean;
+    supportsToolsUseWithJsonSchema: boolean;
+    supportsParallelToolCalls: boolean;
+    supportsToolsEmptyParameters: boolean;
+    supportsTemperature: boolean;
+}
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -71,9 +80,10 @@ export declare class OpenAIChatModel extends ChatModel {
     protected supportsToolsUseWithJsonSchema: boolean;
     protected supportsParallelToolCalls: boolean;
     protected supportsToolsEmptyParameters: boolean;
+    protected supportsTemperature: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<ChatModelOutput>>;
     private getParallelToolCalls;
     private getRunMessages;
     private getRunResponseFormat;
@@ -87,4 +97,3 @@ export declare function toolsFromInputTools(tools?: ChatModelInputTool[], option
     addTypeToEmptyParameters?: boolean;
 }): ChatCompletionTool[] | undefined;
 export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
-export declare function extractResultFromStream(stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>, jsonMode?: boolean): Promise<ChatModelOutput>;

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

@@ -4,9 +4,14 @@ import { z } from "zod";
 import { parseJSON } from "../utils/json-schema.js";
 import { mergeUsage } from "../utils/model-utils.js";
 import { getJsonOutputPrompt } from "../utils/prompts.js";
+import { agentResponseStreamToObject } from "../utils/stream-utils.js";
 import { checkArguments, isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
+const OPENAI_CHAT_MODEL_CAPABILITIES = {
+    "o4-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
+    "o3-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
+};
 export const openAIChatModelOptionsSchema = z.object({
     apiKey: z.string().optional(),
     baseURL: z.string().optional(),
@@ -29,6 +34,8 @@ export class OpenAIChatModel extends ChatModel {
         this.options = options;
         if (options)
             checkArguments(this.name, openAIChatModelOptionsSchema, options);
+        const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : undefined;
+        Object.assign(this, preset);
     }
     _client;
     apiKeyEnvName = "OPENAI_API_KEY";
@@ -38,6 +45,7 @@ export class OpenAIChatModel extends ChatModel {
     supportsToolsUseWithJsonSchema = true;
     supportsParallelToolCalls = true;
     supportsToolsEmptyParameters = true;
+    supportsTemperature = true;
     get client() {
         const apiKey = this.options?.apiKey || process.env[this.apiKeyEnvName] || this.apiKeyDefault;
         if (!apiKey)
@@ -51,14 +59,17 @@ export class OpenAIChatModel extends ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input) {
+    async process(input, _context, options) {
+        const messages = await this.getRunMessages(input);
         const body = {
             model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
-            temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+            temperature: this.supportsTemperature
+                ? (input.modelOptions?.temperature ?? this.modelOptions?.temperature)
+                : undefined,
             top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
             frequency_penalty: input.modelOptions?.frequencyPenalty ?? this.modelOptions?.frequencyPenalty,
             presence_penalty: input.modelOptions?.presencePenalty ?? this.modelOptions?.presencePenalty,
-            messages: await this.getRunMessages(input),
+            messages,
             stream_options: {
                 include_usage: true,
             },
@@ -74,6 +85,9 @@ export class OpenAIChatModel extends ChatModel {
             parallel_tool_calls: this.getParallelToolCalls(input),
             response_format: responseFormat,
         });
+        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+            return await extractResultFromStream(stream, false, true);
+        }
         const result = await extractResultFromStream(stream, jsonMode);
         if (!this.supportsToolsUseWithJsonSchema &&
             !result.toolCalls?.length &&
@@ -221,51 +235,102 @@ export function jsonSchemaToOpenAIJsonSchema(schema) {
     }
     return schema;
 }
-export async function extractResultFromStream(stream, jsonMode = false) {
-    let text = "";
-    const toolCalls = [];
-    let usage;
-    let model;
-    for await (const chunk of stream) {
-        const choice = chunk.choices?.[0];
-        model ??= chunk.model;
-        if (choice?.delta.tool_calls?.length) {
-            for (const call of choice.delta.tool_calls) {
-                // Gemini not support tool call delta
-                if (call.index !== undefined) {
-                    handleToolCallDelta(toolCalls, call);
+async function extractResultFromStream(stream, jsonMode, streaming) {
+    const result = new ReadableStream({
+        async start(controller) {
+            try {
+                let text = "";
+                let refusal = "";
+                const toolCalls = [];
+                let model;
+                for await (const chunk of stream) {
+                    const choice = chunk.choices?.[0];
+                    if (!model) {
+                        model = chunk.model;
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    model,
+                                },
+                            },
+                        });
+                    }
+                    if (choice?.delta.tool_calls?.length) {
+                        for (const call of choice.delta.tool_calls) {
+                            // Gemini not support tool call delta
+                            if (call.index !== undefined) {
+                                handleToolCallDelta(toolCalls, call);
+                            }
+                            else {
+                                handleCompleteToolCall(toolCalls, call);
+                            }
+                        }
+                    }
+                    if (choice?.delta.content) {
+                        text += choice.delta.content;
+                        if (!jsonMode) {
+                            controller.enqueue({
+                                delta: {
+                                    text: {
+                                        text: choice.delta.content,
+                                    },
+                                },
+                            });
+                        }
+                    }
+                    if (choice?.delta.refusal) {
+                        refusal += choice.delta.refusal;
+                        if (!jsonMode) {
+                            controller.enqueue({
+                                delta: {
+                                    text: { text: choice.delta.refusal },
+                                },
+                            });
+                        }
+                    }
+                    if (chunk.usage) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    usage: {
+                                        inputTokens: chunk.usage.prompt_tokens,
+                                        outputTokens: chunk.usage.completion_tokens,
+                                    },
+                                },
+                            },
+                        });
+                    }
                 }
-                else {
-                    handleCompleteToolCall(toolCalls, call);
+                text = text || refusal;
+                if (jsonMode && text) {
+                    controller.enqueue({
+                        delta: {
+                            json: {
+                                json: parseJSON(text),
+                            },
+                        },
+                    });
                 }
+                if (toolCalls.length) {
+                    controller.enqueue({
+                        delta: {
+                            json: {
+                                toolCalls: toolCalls.map(({ args, ...c }) => ({
+                                    ...c,
+                                    function: { ...c.function, arguments: parseJSON(args) },
+                                })),
+                            },
+                        },
+                    });
+                }
+                controller.close();
             }
-        }
-        if (choice?.delta.content)
-            text += choice.delta.content;
-        if (chunk.usage) {
-            usage = {
-                inputTokens: chunk.usage.prompt_tokens,
-                outputTokens: chunk.usage.completion_tokens,
-            };
-        }
-    }
-    const result = {
-        usage,
-        model,
-    };
-    if (jsonMode && text) {
-        result.json = parseJSON(text);
-    }
-    else {
-        result.text = text;
-    }
-    if (toolCalls.length) {
-        result.toolCalls = toolCalls.map(({ args, ...c }) => ({
-            ...c,
-            function: { ...c.function, arguments: parseJSON(args) },
-        }));
-    }
-    return result;
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+    return streaming ? result : await agentResponseStreamToObject(result);
 }
 function handleToolCallDelta(toolCalls, call) {
     toolCalls[call.index] ??= {

package/lib/esm/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/esm/utils/camelize.js

@@ -0,0 +1,10 @@
+import camelize from "camelize-ts";
+export 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 {
+        ...camelize(shallow, true),
+        ...camelize(deep),
+    };
+}
+const _unique = Symbol();

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

@@ -0,0 +1,17 @@
+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;
+export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
+export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
+export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
+    errorCallback?: (error: Error) => Error;
+    processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
+}): ReadableStream<any>;
+export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
+export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
+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/utils/stream-utils.js

@@ -0,0 +1,149 @@
+import equal from "fast-deep-equal";
+import { isEmptyChunk, } from "../agents/agent.js";
+import { omitBy } from "./type-utils.js";
+export function objectToAgentResponseStream(json) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ delta: { json } });
+            controller.close();
+        },
+    });
+}
+export function mergeAgentResponseChunk(output, chunk) {
+    if (chunk.delta.text) {
+        for (const [key, text] of Object.entries(chunk.delta.text)) {
+            const original = output[key];
+            const t = (original || "") + (text || "");
+            if (t)
+                Object.assign(output, { [key]: t });
+        }
+    }
+    if (chunk.delta.json) {
+        Object.assign(output, omitBy(chunk.delta.json, (v) => v === undefined));
+    }
+    return output;
+}
+export async function agentResponseStreamToObject(stream) {
+    const json = {};
+    if (stream instanceof ReadableStream) {
+        for await (const value of readableStreamToAsyncIterator(stream)) {
+            mergeAgentResponseChunk(json, value);
+        }
+    }
+    else {
+        for (;;) {
+            const chunk = await stream.next();
+            if (chunk.value) {
+                if (chunk.done) {
+                    Object.assign(json, chunk.value);
+                }
+                else {
+                    mergeAgentResponseChunk(json, chunk.value);
+                }
+            }
+            if (chunk.done)
+                break;
+        }
+    }
+    return json;
+}
+export function asyncGeneratorToReadableStream(generator) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for (;;) {
+                    const chunk = await generator.next();
+                    if (chunk.value) {
+                        if (chunk.done) {
+                            controller.enqueue({ delta: { json: chunk.value } });
+                        }
+                        else {
+                            controller.enqueue(chunk.value);
+                        }
+                    }
+                    if (chunk.done)
+                        break;
+                }
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+export function onAgentResponseStreamEnd(stream, callback, options) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                const json = {};
+                for await (const value of readableStreamToAsyncIterator(stream)) {
+                    const chunk = options?.processChunk ? options.processChunk(value) : value;
+                    if (!isEmptyChunk(chunk))
+                        controller.enqueue(chunk);
+                    mergeAgentResponseChunk(json, value);
+                }
+                const result = await callback(json);
+                if (result && !equal(result, json)) {
+                    let chunk = { delta: { json: result } };
+                    if (options?.processChunk)
+                        chunk = options.processChunk(chunk);
+                    controller.enqueue(chunk);
+                }
+            }
+            catch (error) {
+                controller.error(options?.errorCallback?.(error) ?? error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+export function isAsyncGenerator(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+export async function* arrayToAgentProcessAsyncGenerator(chunks, result) {
+    for (const chunk of chunks) {
+        if (chunk instanceof Error)
+            throw chunk;
+        yield chunk;
+    }
+    if (result !== undefined)
+        return result;
+}
+export function arrayToAgentResponseStream(chunks) {
+    return new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks) {
+                if (chunk instanceof Error) {
+                    controller.error(chunk);
+                    return;
+                }
+                controller.enqueue(chunk);
+            }
+            controller.close();
+        },
+    });
+}
+export async function readableStreamToArray(stream) {
+    const result = [];
+    for await (const value of readableStreamToAsyncIterator(stream)) {
+        result.push(value);
+    }
+    return result;
+}
+export async function* readableStreamToAsyncIterator(stream) {
+    const reader = stream.getReader();
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        yield value;
+    }
+}
+export 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/esm/utils/type-utils.d.ts

@@ -7,6 +7,7 @@ export declare function isEmpty(obj: unknown): boolean;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
 export declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
 export declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
+export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
 export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;

package/lib/esm/utils/type-utils.js

@@ -31,6 +31,12 @@ export function duplicates(arr, key = (item) => item) {
     }
     return Array.from(duplicates);
 }
+export function omitBy(obj, predicate) {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+        const k = key;
+        return !predicate(value, k);
+    }));
+}
 export function orArrayToArray(value) {
     if (isNil(value))
         return [];

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@aigne/core",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "AIGNE core library for building AI-powered applications",
   "publishConfig": {
     "access": "public"
   },
   "author": "Arcblock <blocklet@arcblock.io> https://github.com/blocklet",
   "homepage": "https://github.com/AIGNE-io/aigne-framework",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AIGNE-io/aigne-framework"
@@ -65,7 +65,9 @@
     "@aigne/json-schema-to-zod": "^1.3.3",
     "@modelcontextprotocol/sdk": "^1.9.0",
     "@types/debug": "^4.1.12",
+    "camelize-ts": "^3.0.0",
     "debug": "^4.4.0",
+    "fast-deep-equal": "^3.1.3",
     "inquirer": "^12.5.2",
     "mustache": "^4.2.0",
     "nanoid": "^5.1.5",