@aigne/core 1.10.0 → 1.12.0

package/lib/dts/{execution-engine → aigne}/context.d.ts

@@ -1,12 +1,11 @@
 import EventEmitter from "node:events";
-import { Agent, type AgentCallOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type FunctionAgentFn, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, 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";
 import type { Args, Listener, TypedEventEmitter } from "../utils/typed-event-emtter.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import { type ContextLimits, type ContextUsage } from "./usage.js";
-export type Runnable<I extends Message = Message, O extends Message = Message> = Agent<I, O> | FunctionAgentFn;
 export interface AgentEvent {
     parentContextId?: string;
     contextId: string;
@@ -27,53 +26,53 @@ export interface ContextEventMap {
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
-export interface CallOptions extends AgentCallOptions {
+export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
 export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
-    tools?: Agent[];
+    skills?: Agent[];
     usage: ContextUsage;
     limits?: ContextLimits;
     status?: "normal" | "timeout";
     /**
-     * Create a user agent to consistently call an agent
-     * @param agent Agent to call
+     * Create a user agent to consistently invoke an agent
+     * @param agent Agent to invoke
      * @returns User agent
      */
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>): UserAgent<I, O>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
     /**
-     * Call an agent with a message and return the output and the active agent
-     * @param agent Agent to call
+     * Invoke an agent with a message and return the output and the active agent
+     * @param agent Agent to invoke
      * @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 & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming?: false;
-    }): Promise<[O, Runnable]>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    }): Promise<[O, Agent]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         returnActiveAgent: true;
         streaming: true;
-    }): Promise<[AgentResponseStream<O>, Promise<Runnable>]>;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
     /**
-     * Call an agent with a message
-     * @param agent Agent to call
+     * Invoke an agent with a message
+     * @param agent Agent to invoke
      * @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 & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    call<I extends Message, O extends Message>(agent: Runnable<I, O>, message: I | string, options: CallOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
         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]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I | string, options?: InvokeOptions): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
     /**
-     * Publish a message to a topic, the engine will call the listeners of the topic
+     * Publish a message to a topic, the aigne will invoke the listeners of the topic
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
@@ -96,21 +95,21 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
     }): Context;
 }
 export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
-export declare class ExecutionContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof ExecutionContextInternal>[0]);
+export declare class AIGNEContext implements Context {
+    constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
     parentId?: string;
     id: string;
-    readonly internal: ExecutionContextInternal;
+    readonly internal: AIGNEContextInternal;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     get status(): "normal" | "timeout";
     get usage(): ContextUsage;
     newContext({ reset }?: {
         reset?: boolean;
-    }): ExecutionContext;
-    call: Context["call"];
-    private onCallSuccess;
+    }): AIGNEContext;
+    invoke: Context["invoke"];
+    private onInvokeSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
@@ -119,24 +118,24 @@ export declare class ExecutionContext implements Context {
     once<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
     off<K extends keyof ContextEventMap>(eventName: K, listener: Listener<K, ContextEventMap>): this;
 }
-declare class ExecutionContextInternal {
+declare class AIGNEContextInternal {
     private readonly parent?;
-    constructor(parent?: (Pick<Context, "model" | "tools" | "limits"> & {
+    constructor(parent?: (Pick<Context, "model" | "skills" | "limits"> & {
         messageQueue?: MessageQueue;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
-    get tools(): Agent<Message, Message>[] | undefined;
+    get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
     private abortController;
     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): AgentProcessAsyncGenerator<O & {
-        __activeAgent__: Runnable;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, input: I, context: Context, options?: InvokeOptions): AgentProcessAsyncGenerator<O & {
+        __activeAgent__: Agent;
     }>;
-    private callAgent;
+    private invokeAgent;
 }
 export {};

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

@@ -0,0 +1,4 @@
+export * from "./context.js";
+export * from "./aigne.js";
+export * from "./message-queue.js";
+export * from "./usage.js";

package/lib/dts/{execution-engine → aigne}/usage.d.ts

@@ -6,6 +6,6 @@ export interface ContextUsage {
 export declare function newEmptyContextUsage(): ContextUsage;
 export interface ContextLimits {
     maxTokens?: number;
-    maxAgentCalls?: number;
+    maxAgentInvokes?: number;
     timeout?: number;
 }

package/lib/dts/client/client.d.ts

@@ -0,0 +1,19 @@
+import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
+export interface AIGNEClientOptions {
+    url: string;
+}
+export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
+    fetchOptions?: Partial<RequestInit>;
+}
+export declare class AIGNEClient {
+    options: AIGNEClientOptions;
+    constructor(options: AIGNEClientOptions);
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
+        streaming?: false;
+    }): Promise<O>;
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
+    fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
+}

package/lib/dts/index.d.ts

@@ -2,9 +2,10 @@ export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/memory.js";
+export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
-export * from "./execution-engine/index.js";
+export * from "./aigne/index.js";
 export * from "./models/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

@@ -3,20 +3,23 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     type: "ai";
     name: string;
     description?: string | undefined;
-    tools?: string[] | undefined;
+    memory?: true | {
+        subscribeTopic?: string[] | undefined;
+    } | undefined;
+    skills?: string[] | undefined;
     instructions?: 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;
-    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

@@ -7,7 +7,7 @@ export interface LoadOptions {
 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>[];
+    skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
     description?: string | null | undefined;
     name?: string | null | undefined;
     chat_model?: {
@@ -61,11 +61,11 @@ declare const aigneFileSchema: z.ZodObject<{
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    skills: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
 }, "strip", z.ZodTypeAny, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -77,8 +77,8 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }, {
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -91,8 +91,8 @@ declare const aigneFileSchema: z.ZodObject<{
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
-    tools?: string[] | null | undefined;
     name?: string | null | undefined;
+    skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;

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

@@ -1,5 +1,5 @@
 import { Agent, type Message } from "../agents/agent.js";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
     protected supportsParallelToolCalls: boolean;

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 { AgentInvokeOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../aigne/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?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
     private extractResultFromClaudeStream;
     private requestStructuredOutput;
 }

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

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
 import { z } from "zod";
-import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
-import type { Context } from "../execution-engine/context.js";
+import type { AgentInvokeOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../aigne/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;
@@ -83,7 +83,7 @@ export declare class OpenAIChatModel extends ChatModel {
     protected supportsTemperature: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<ChatModelOutput>>;
+    process(input: ChatModelInput, _context: Context, options?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
     private getParallelToolCalls;
     private getRunMessages;
     private getRunResponseFormat;

package/lib/dts/prompt/prompt-builder.d.ts

@@ -2,7 +2,7 @@ import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { AgentMemory } from "../agents/memory.js";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";

package/lib/dts/server/error.d.ts

@@ -0,0 +1,4 @@
+export declare class ServerError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}

package/lib/dts/server/server.d.ts

@@ -0,0 +1,54 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { z } from "zod";
+import type { AIGNE } from "../aigne/aigne.js";
+export declare const invokePayloadSchema: z.ZodObject<{
+    agent: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    options: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        streaming?: boolean | null | undefined;
+    }, {
+        streaming?: boolean | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    input: Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}, {
+    agent: string;
+    input: Record<string, unknown>;
+    options?: {
+        streaming?: boolean | null | undefined;
+    } | null | undefined;
+}>;
+export interface AIGNEServerOptions {
+    /**
+     * Maximum body size for the request.
+     * Only used when the request is a Node.js IncomingMessage and no `body` property is present.
+     * @default "4mb"
+     */
+    maximumBodySize?: string;
+}
+export declare class AIGNEServer {
+    engine: AIGNE;
+    options?: AIGNEServerOptions | undefined;
+    constructor(engine: AIGNE, options?: AIGNEServerOptions | undefined);
+    /**
+     * Invoke the agent with the given input.
+     * @param request - The request object, which can be a parsed JSON object, a Fetch API Request object, or a Node.js IncomingMessage object.
+     * @returns The web standard response, you can return it directly in supported frameworks like hono.
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    /**
+     * Invoke the agent with the given input, and write the SSE response to the Node.js ServerResponse.
+     * @param request - The request object, which can be a parsed JSON object, a Fetch API Request object, or a Node.js IncomingMessage object.
+     * @param response - The Node.js ServerResponse object to write the SSE response to.
+     */
+    invoke(request: Record<string, unknown> | Request | IncomingMessage, response: ServerResponse): Promise<void>;
+    _invoke(request: Record<string, unknown> | Request | IncomingMessage): Promise<Response>;
+    _prepareInput(request: Record<string, unknown> | Request | IncomingMessage): Promise<Record<string, unknown>>;
+    _writeResponse(response: Response, res: ServerResponse): Promise<void>;
+}

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/event-stream.d.ts

@@ -0,0 +1,11 @@
+import type { AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+export declare class EventStreamParser<T> extends TransformStream<string, T | Error> {
+    constructor();
+}
+export declare class AgentResponseStreamParser<O extends Message> extends TransformStream<AgentResponseChunk<O> | Error, AgentResponseChunk<O>> {
+    private json;
+    constructor();
+}
+export declare class AgentResponseStreamSSE<O extends Message> extends ReadableStream<string> {
+    constructor(stream: AgentResponseStream<O>);
+}

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;
@@ -10,6 +11,12 @@ export declare function onAgentResponseStreamEnd<T extends Message>(stream: Agen
 }): 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 arrayToReadableStream<T>(chunks: (T | Error)[]): ReadableStream<T>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options: {
+    catchError: true;
+}): Promise<(T | Error)[]>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>, options?: {
+    catchError?: false;
+}): 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/dts/utils/type-utils.d.ts

@@ -1,8 +1,9 @@
 import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
-export type Nullish<T> = T | null | undefined;
+export type Nullish<T> = T | null | undefined | void;
 export type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
 export declare function isNil(value: unknown): value is null | undefined;
+export declare function isRecord<T>(value: unknown): value is Record<string, T>;
 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[]];
@@ -12,5 +13,6 @@ 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): T;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T | unknown): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
+export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;

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

@@ -1,6 +1,6 @@
 import { inspect } from "node:util";
 import { type ZodType } from "zod";
-import type { Context } from "../execution-engine/context.js";
+import type { Context } from "../aigne/context.js";
 import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
 import { AgentMemory, type AgentMemoryOptions } from "./memory.js";
 import { type TransferAgentOutput } from "./types.js";
@@ -15,11 +15,11 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     inputSchema?: AgentInputOutputSchema<I>;
     outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
-    tools?: (Agent | FunctionAgentFn)[];
+    skills?: (Agent | FunctionAgentFn)[];
     disableEvents?: boolean;
     memory?: AgentMemory | AgentMemoryOptions | true;
 }
-export interface AgentCallOptions {
+export interface AgentInvokeOptions {
     streaming?: boolean;
 }
 export declare abstract class Agent<I extends Message = Message, O extends Message = Message> {
@@ -38,52 +38,53 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     readonly includeInputInOutput?: boolean;
     readonly subscribeTopic?: SubscribeTopic;
     readonly publishTopic?: PublishTopic<Message>;
-    readonly tools: Agent<Message, Message>[] & {
+    readonly skills: Agent<Message, Message>[] & {
         [key: string]: Agent<Message, Message>;
     };
     private disableEvents?;
     /**
      * Attach agent to context:
-     * - subscribe to topic and call process method when message received
+     * - subscribe to topic and invoke process method when message received
      * - subscribe to memory topic if memory is enabled
      * @param context Context to attach
      */
     attach(context: Pick<Context, "subscribe">): void;
-    addTool<I extends Message, O extends Message>(tool: Agent<I, O> | FunctionAgentFn<I, O>): void;
-    get isCallable(): boolean;
+    addSkill(...skills: (Agent | FunctionAgentFn)[]): void;
+    get isInvokable(): boolean;
     private checkContextStatus;
     private newDefaultContext;
-    call(input: I | string, context: Context | undefined, options: AgentCallOptions & {
+    invoke(input: I | string, context: Context | undefined, options: AgentInvokeOptions & {
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
-    call(input: I | string, context?: Context, options?: AgentCallOptions & {
+    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
-    call(input: I | string, context?: Context, options?: AgentCallOptions): Promise<AgentResponse<O>>;
+    invoke(input: I | string, context?: Context, options?: AgentInvokeOptions): Promise<AgentResponse<O>>;
     private processAgentOutput;
     private processAgentError;
-    protected checkUsageAgentCalls(context: Context): void;
+    protected checkAgentInvokesUsage(context: Context): void;
     protected preprocess(_: I, context: Context): void;
     protected postprocess(input: I, output: O, context: Context): void;
-    abstract process(input: I, context: Context, options?: AgentCallOptions): AgentProcessResult<O | TransferAgentOutput>;
+    abstract process(input: I, context: Context, options?: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
     shutdown(): Promise<void>;
     [inspect.custom](): string;
 }
-export type AgentResponse<T> = T | AgentResponseStream<T>;
+export type AgentResponse<T> = T | TransferAgentOutput | AgentResponseStream<T>;
 export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
 export type AgentResponseChunk<T> = AgentResponseDelta<T>;
+export declare function isEmptyChunk<T>(chunk: AgentResponseChunk<T>): boolean;
 export interface AgentResponseDelta<T> {
     delta: {
         text?: Partial<{
             [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
-        }> | {
+        }> | Partial<{
             [key: string]: string;
-        };
-        json?: Partial<T>;
+        }>;
+        json?: Partial<T | TransferAgentOutput>;
     };
 }
-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 AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O | TransferAgentOutput> | undefined | void>;
+export type AgentProcessResult<O extends Message> = AgentResponse<O> | AgentProcessAsyncGenerator<O> | Agent;
 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>;
@@ -92,6 +93,6 @@ export declare class FunctionAgent<I extends Message = Message, O extends Messag
     static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
     constructor(options: FunctionAgentOptions<I, O>);
     fn: FunctionAgentFn<I, O>;
-    process(input: I, context: Context, options?: AgentCallOptions): Promise<AgentResponse<O | TransferAgentOutput>>;
+    process(input: I, context: Context): PromiseOrValue<AgentProcessResult<O>>;
 }
-export type FunctionAgentFn<I extends Message = Message, O extends Message = Message> = (input: I, context: Context) => O | Promise<O> | Agent | Promise<Agent>;
+export type FunctionAgentFn<I extends Message = any, O extends Message = any> = (input: I, context: Context) => PromiseOrValue<AgentProcessResult<O>>;