@aigne/core 1.8.0 → 1.10.0

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

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToAgentResponseStream = objectToAgentResponseStream;
+exports.mergeAgentResponseChunk = mergeAgentResponseChunk;
+exports.agentResponseStreamToObject = agentResponseStreamToObject;
+exports.asyncGeneratorToReadableStream = asyncGeneratorToReadableStream;
+exports.onAgentResponseStreamEnd = onAgentResponseStreamEnd;
+exports.isAsyncGenerator = isAsyncGenerator;
+exports.arrayToAgentProcessAsyncGenerator = arrayToAgentProcessAsyncGenerator;
+exports.arrayToAgentResponseStream = arrayToAgentResponseStream;
+exports.readableStreamToArray = readableStreamToArray;
+exports.readableStreamToAsyncIterator = readableStreamToAsyncIterator;
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const type_utils_js_1 = require("./type-utils.js");
+function objectToAgentResponseStream(json) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ delta: { json } });
+            controller.close();
+        },
+    });
+}
+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, (0, type_utils_js_1.omitBy)(chunk.delta.json, (v) => v === undefined));
+    }
+    return output;
+}
+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;
+}
+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;
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+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;
+                    controller.enqueue(chunk);
+                    mergeAgentResponseChunk(json, value);
+                }
+                const result = await callback(json);
+                if (result && !(0, fast_deep_equal_1.default)(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();
+            }
+        },
+    });
+}
+function isAsyncGenerator(value) {
+    return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+async function* arrayToAgentProcessAsyncGenerator(chunks, result) {
+    for (const chunk of chunks) {
+        if (chunk instanceof Error)
+            throw chunk;
+        yield chunk;
+    }
+    if (result !== undefined)
+        return result;
+}
+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();
+        },
+    });
+}
+async function readableStreamToArray(stream) {
+    const result = [];
+    for await (const value of readableStreamToAsyncIterator(stream)) {
+        result.push(value);
+    }
+    return result;
+}
+async function* readableStreamToAsyncIterator(stream) {
+    const reader = stream.getReader();
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        yield value;
+    }
+}

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

@@ -7,9 +7,10 @@ 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;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;

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

@@ -5,6 +5,7 @@ exports.isEmpty = isEmpty;
 exports.isNonNullable = isNonNullable;
 exports.isNotEmpty = isNotEmpty;
 exports.duplicates = duplicates;
+exports.omitBy = omitBy;
 exports.orArrayToArray = orArrayToArray;
 exports.createAccessorArray = createAccessorArray;
 exports.checkArguments = checkArguments;
@@ -42,6 +43,12 @@ function duplicates(arr, key = (item) => item) {
     }
     return Array.from(duplicates);
 }
+function omitBy(obj, predicate) {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+        const k = key;
+        return !predicate(value, k);
+    }));
+}
 function orArrayToArray(value) {
     if (isNil(value))
         return [];
@@ -54,7 +61,7 @@ function createAccessorArray(array, accessor) {
 }
 function checkArguments(prefix, schema, args) {
     try {
-        schema.parse(args, {
+        return schema.parse(args, {
             errorMap: (issue, ctx) => {
                 if (issue.code === "invalid_union") {
                     // handle all issues that are not invalid_type

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

@@ -19,6 +19,9 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
+export interface AgentCallOptions {
+    streaming?: boolean;
+}
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
     constructor({ inputSchema, outputSchema, ...options }: AgentOptions<I, O>);
     readonly memory?: AgentMemory;
@@ -50,14 +53,37 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     get isCallable(): boolean;
     private checkContextStatus;
     private newDefaultContext;
-    call(input: I | string, context?: Context): Promise<O>;
+    call(input: I | string, context: Context | undefined, options: AgentCallOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions): Promise<AgentResponse<O>>;
+    private processAgentOutput;
+    private processAgentError;
     protected checkUsageAgentCalls(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
-    abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
+    abstract process(input: I, context: Context, options?: AgentCallOptions): AgentProcessResult<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
     [inspect.custom](): string;
 }
+export type AgentResponse<T> = T | AgentResponseStream<T>;
+export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
+export type AgentResponseChunk<T> = AgentResponseDelta<T>;
+export interface AgentResponseDelta<T> {
+    delta: {
+        text?: Partial<{
+            [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
+        }> | {
+            [key: string]: string;
+        };
+        json?: Partial<T>;
+    };
+}
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | undefined | void>;
+export type AgentProcessResult<O extends Message> = Promise<AgentResponse<O>> | AgentProcessAsyncGenerator<O>;
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
@@ -66,6 +92,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context: Context): Promise<TransferAgentOutput | O>;
+    process(input: I, context: Context, options?: AgentCallOptions): Promise<AgentResponse<O | TransferAgentOutput>>;
 }
 export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;

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

@@ -2,7 +2,8 @@ import { z } from "zod";
 import type { Context } from "../execution-engine/context.js";
 import { ChatModel } from "../models/chat-model.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
-import { Agent, type AgentOptions, type Message } from "./agent.js";
+import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
+import { type TransferAgentOutput } from "./types.js";
 export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     model?: ChatModel;
     instructions?: string | PromptBuilder;
@@ -64,5 +65,5 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
-    process(input: I, context: Context): Promise<import("./types.js").TransferAgentOutput | O>;
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O | TransferAgentOutput>;
 }

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

@@ -2,7 +2,7 @@ import { ReadableStream } from "node:stream/web";
 import { type Context, type Runnable } from "../execution-engine/context.js";
 import type { MessagePayload } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
-import { Agent, type AgentOptions, type Message } from "./agent.js";
+import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
     process?: (input: I, context: Context) => PromiseOrValue<O>;
@@ -14,8 +14,8 @@ export declare class UserAgent<I extends Message = Message, O extends Message =
     context: Context;
     private _process?;
     private activeAgent?;
-    call(input: string | I, context?: Context): Promise<O>;
-    process(input: I, context: Context): Promise<O>;
+    call: Agent<I, O>["call"];
+    process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];

package/lib/dts/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/dts/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/dts/models/deepseek-chat-model.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class DeepSeekChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsToolsEmptyParameters: boolean;
+}

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

@@ -0,0 +1,8 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class GeminiChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+}

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

@@ -0,0 +1,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OllamaChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string;
+}

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

@@ -0,0 +1,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsParallelToolCalls: boolean;
+}

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

@@ -1,6 +1,17 @@
 import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
 import { z } from "zod";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+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;
@@ -62,7 +73,27 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     protected _client?: OpenAI;
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string | undefined;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsEndWithSystemMessage: boolean;
+    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;
+    private requestStructuredOutput;
 }
+export declare const ROLE_MAP: {
+    [key in Role]: ChatCompletionMessageParam["role"];
+};
+export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
+    addTypeToEmptyParameters?: boolean;
+}): ChatCompletionTool[] | undefined;
+export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;

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

@@ -1,13 +1,5 @@
-import OpenAI from "openai";
-import type { ChatModelOptions } from "./chat-model.js";
-import { OpenAIChatModel } from "./openai-chat-model.js";
-export interface XAIChatModelOptions {
-    apiKey?: string;
-    model?: string;
-    modelOptions?: ChatModelOptions;
-    baseURL?: string;
-}
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
 export declare class XAIChatModel extends OpenAIChatModel {
-    constructor(options?: XAIChatModelOptions);
-    get client(): OpenAI;
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
 }

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

@@ -0,0 +1 @@
+export declare function getJsonOutputPrompt(schema: Record<string, unknown> | string): string;

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

@@ -0,0 +1,15 @@
+import type { AgentProcessAsyncGenerator, AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.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>;

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

@@ -7,9 +7,10 @@ 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;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;

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

@@ -19,6 +19,9 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
+export interface AgentCallOptions {
+    streaming?: boolean;
+}
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
     constructor({ inputSchema, outputSchema, ...options }: AgentOptions<I, O>);
     readonly memory?: AgentMemory;
@@ -50,14 +53,37 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     get isCallable(): boolean;
     private checkContextStatus;
     private newDefaultContext;
-    call(input: I | string, context?: Context): Promise<O>;
+    call(input: I | string, context: Context | undefined, options: AgentCallOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    call(input: I | string, context?: Context, options?: AgentCallOptions): Promise<AgentResponse<O>>;
+    private processAgentOutput;
+    private processAgentError;
     protected checkUsageAgentCalls(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
-    abstract process(input: I, context: Context): Promise<O | TransferAgentOutput>;
+    abstract process(input: I, context: Context, options?: AgentCallOptions): AgentProcessResult<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
     [inspect.custom](): string;
 }
+export type AgentResponse<T> = T | AgentResponseStream<T>;
+export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
+export type AgentResponseChunk<T> = AgentResponseDelta<T>;
+export interface AgentResponseDelta<T> {
+    delta: {
+        text?: Partial<{
+            [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
+        }> | {
+            [key: string]: string;
+        };
+        json?: Partial<T>;
+    };
+}
+export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | undefined | void>;
+export type AgentProcessResult<O extends Message> = Promise<AgentResponse<O>> | AgentProcessAsyncGenerator<O>;
 export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
@@ -66,6 +92,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context: Context): Promise<TransferAgentOutput | O>;
+    process(input: I, context: Context, options?: AgentCallOptions): Promise<AgentResponse<O | TransferAgentOutput>>;
 }
 export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;