@aigne/core 1.15.0 → 1.16.0

package/lib/cjs/utils/logger.js

@@ -3,10 +3,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const node_tty_1 = require("node:tty");
 const debug_1 = __importDefault(require("debug"));
-const base = (0, debug_1.default)("aigne");
-exports.logger = Object.assign(debug_1.default, {
-    core: base.extend("core"),
-    mcp: base.extend("mcp"),
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const levels = Object.values(LogLevel);
+class Logger {
+    constructor(options) {
+        this.level = options.level;
+        this.debugLogger = (0, debug_1.default)(`${options.ns}:debug`);
+        this.infoLogger = (0, debug_1.default)(`${options.ns}:info`);
+        this.warnLogger = (0, debug_1.default)(`${options.ns}:warn`);
+        this.errorLogger = (0, debug_1.default)(`${options.ns}:error`);
+        for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
+            // @ts-ignore
+            logger.useColors = (0, node_tty_1.isatty)(process.stdout.fd);
+            logger.enabled = true;
+            logger.log = (...args) => this.logMessage(...args);
+        }
+        this.errorLogger.log = (...args) => this.logError(...args);
+        // @ts-ignore
+        this.errorLogger.useColors = (0, node_tty_1.isatty)(process.stderr.fd);
+        this.errorLogger.enabled = true;
+    }
+    level;
+    debugLogger;
+    infoLogger;
+    warnLogger;
+    errorLogger;
+    logMessage = console.log;
+    logError = console.error;
+    debug(message, ...args) {
+        if (this.enabled(LogLevel.DEBUG)) {
+            this.debugLogger(message, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.enabled(LogLevel.INFO)) {
+            this.infoLogger(message, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.enabled(LogLevel.WARN)) {
+            this.warnLogger(message, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.enabled(LogLevel.ERROR)) {
+            this.errorLogger(message, ...args);
+        }
+    }
+    enabled(level) {
+        return levels.indexOf(this.level) >= levels.indexOf(level);
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger({
+    ns: "aigne:core",
+    level: LogLevel.INFO,
 });

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

@@ -1,3 +1,3 @@
-import type { ChatModelOutputUsage } from "../models/chat-model.js";
+import type { ChatModelOutputUsage } from "../agents/chat-model.js";
 import type { Nullish } from "./type-utils.js";
 export declare function mergeUsage(...usages: Nullish<ChatModelOutputUsage>[]): ChatModelOutputUsage;

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

@@ -6,7 +6,7 @@ export declare function mergeAgentResponseChunk<T extends Message>(output: T, ch
 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;
+    errorCallback?: (error: Error) => PromiseOrValue<Error>;
     processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
 }): ReadableStream<any>;
 export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
@@ -19,3 +19,5 @@ export declare function readableStreamToArray<T>(stream: ReadableStream<T>, opti
     catchError?: false;
 }): Promise<T[]>;
 export declare function stringToAgentResponseStream(str: string, key?: "text" | typeof MESSAGE_KEY | string): AgentResponseStream<Message>;
+export declare function toReadableStream(stream: NodeJS.ReadStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
+export declare function readAllString(stream: NodeJS.ReadStream | ReadableStream): Promise<string>;

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

@@ -13,6 +13,8 @@ exports.arrayToAgentProcessAsyncGenerator = arrayToAgentProcessAsyncGenerator;
 exports.arrayToReadableStream = arrayToReadableStream;
 exports.readableStreamToArray = readableStreamToArray;
 exports.stringToAgentResponseStream = stringToAgentResponseStream;
+exports.toReadableStream = toReadableStream;
+exports.readAllString = readAllString;
 const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("./type-utils.js");
@@ -113,7 +115,7 @@ function onAgentResponseStreamEnd(stream, callback, options) {
                 }
             }
             catch (error) {
-                controller.error(options?.errorCallback?.(error) ?? error);
+                controller.error((await options?.errorCallback?.(error)) ?? error);
             }
         },
     });
@@ -166,3 +168,31 @@ function stringToAgentResponseStream(str, key = "text") {
     const segments = segmenter.segment(str);
     return arrayToReadableStream(Array.from(segments).map((segment) => ({ delta: { text: { [key]: segment.segment } } })));
 }
+function toReadableStream(stream) {
+    return new ReadableStream({
+        start(controller) {
+            const onData = (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            };
+            const onEnd = () => {
+                cleanup();
+                controller.close();
+            };
+            const onError = (err) => {
+                cleanup();
+                controller.error(err);
+            };
+            function cleanup() {
+                stream.off("data", onData);
+                stream.off("end", onEnd);
+                stream.off("error", onError);
+            }
+            stream.on("data", onData);
+            stream.on("end", onEnd);
+            stream.on("error", onError);
+        },
+    });
+}
+async function readAllString(stream) {
+    return (await readableStreamToArray((stream instanceof ReadableStream ? stream : toReadableStream(stream)).pipeThrough(new TextDecoderStream()))).join("");
+}

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

@@ -2,6 +2,11 @@ import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 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 type XOr<T, K extends keyof T, O extends keyof T> = (Omit<T, O> & {
+    [key in O]?: undefined;
+}) | (Omit<T, K> & {
+    [key in K]?: undefined;
+});
 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;

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

@@ -3,7 +3,8 @@ import { ZodObject, type ZodType } from "zod";
 import type { Context } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryAgent } from "../memory/memory.js";
-import { type Nullish, type PromiseOrValue } from "../utils/type-utils.js";
+import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
+import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import { type TransferAgentOutput } from "./types.js";
 export * from "./types.js";
 /**
@@ -29,7 +30,7 @@ export type PublishTopic<O extends Message> = string | string[] | ((output: O) =
  * @template I The agent input message type
  * @template O The agent output message type
  */
-export interface AgentOptions<I extends Message = Message, O extends Message = Message> {
+export interface AgentOptions<I extends Message = Message, O extends Message = Message> extends Partial<Pick<Agent, "guideRails" | "hooks">> {
     /**
      * Topics the agent should subscribe to
      *
@@ -139,6 +140,35 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * List of memories this agent can use
      */
     readonly memories: MemoryAgent[];
+    /**
+     * Lifecycle hooks for agent processing.
+     *
+     * Hooks enable tracing, logging, monitoring, and custom behavior
+     * without modifying the core agent implementation
+     *
+     * @example
+     * Here's an example of using hooks:
+     * {@includeCode ../../test/agents/agent.test.ts#example-agent-hooks}
+     */
+    readonly hooks: AgentHooks;
+    /**
+     * List of GuideRail agents applied to this agent
+     *
+     * GuideRail agents validate, transform, or control the message flow by:
+     * - Enforcing rules and safety policies
+     * - Validating inputs/outputs against specific criteria
+     * - Implementing business logic validations
+     * - Monitoring and auditing agent behavior
+     *
+     * Each GuideRail agent can examine both input and expected output,
+     * and has the ability to abort the process with an explanation
+     *
+     * @example
+     * Here's an example of using GuideRail agents:
+     *
+     * {@includeCode ../../test/agents/agent.test.ts#example-agent-guide-rails}
+     */
+    readonly guideRails?: GuideRailAgent[];
     /**
      * Name of the agent, used for identification and logging
      *
@@ -301,6 +331,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * @returns Agent response (streaming or regular)
      */
     invoke(input: I | string, context?: Context, options?: AgentInvokeOptions): Promise<AgentResponse<O>>;
+    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I, context: Context): Promise<O>;
     /**
      * Process agent output
      *
@@ -319,7 +350,6 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      *
      * @param error Caught error
      * @param context Execution context
-     * @throws Always throws the received error
      */
     private processAgentError;
     /**
@@ -342,7 +372,25 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * @param _ Input message (unused)
      * @param context Execution context
      */
-    protected preprocess(_: I, context: Context): void;
+    protected preprocess(_: I, context: Context): PromiseOrValue<void>;
+    private checkResponseByGuideRails;
+    private runGuideRails;
+    /**
+     * Handle errors detected by GuideRail agents
+     *
+     * This method is called when a GuideRail agent aborts the process, providing
+     * a way for agents to customize error handling behavior. By default, it simply
+     * returns the original error, but subclasses can override this method to:
+     * - Transform the error into a more specific response
+     * - Apply recovery strategies
+     * - Log or report the error in a custom format
+     * - Return a fallback output instead of an error
+     *
+     * @param error The GuideRail agent output containing abort=true and a reason
+     * @returns Either the original/modified error or a substitute output object
+     *          which will be tagged with $status: "GuideRailError"
+     */
+    protected onGuideRailError(error: GuideRailAgentOutput): Promise<O | GuideRailAgentOutput>;
     /**
      * Post-processing operations after handling output
      *
@@ -354,7 +402,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      * @param output Output message
      * @param context Execution context
      */
-    protected postprocess(input: I, output: O, context: Context): void;
+    protected postprocess(input: I, output: O, context: Context): PromiseOrValue<void>;
     protected publishToTopics(output: Message, context: Context): Promise<void>;
     /**
      * Core processing method of the agent, must be implemented in subclasses
@@ -419,6 +467,81 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      */
     [Symbol.asyncDispose](): Promise<void>;
 }
+/**
+ * Lifecycle hooks for agent execution
+ *
+ * Hooks provide a way to intercept and extend agent behavior at key points during
+ * the agent's lifecycle, enabling custom functionality like logging, monitoring,
+ * tracing, error handling, and more.
+ */
+export interface AgentHooks<I extends Message = Message, O extends Message = Message> {
+    /**
+     * Called when agent processing begins
+     *
+     * This hook runs before the agent processes input, allowing for
+     * setup operations, logging, or input transformations.
+     *
+     * @param event Object containing the input message
+     */
+    onStart?: (event: {
+        input: I;
+    }) => PromiseOrValue<void>;
+    /**
+     * Called when agent processing completes or fails
+     *
+     * This hook runs after processing finishes, receiving either the output
+     * or an error if processing failed. Useful for cleanup operations,
+     * logging results, or error handling.
+     *
+     * @param event Object containing the input message and either output or error
+     */
+    onEnd?: (event: XOr<{
+        input: I;
+        output: O;
+        error: Error;
+    }, "output", "error">) => PromiseOrValue<void>;
+    /**
+     * Called before a skill (sub-agent) is invoked
+     *
+     * This hook runs when the agent delegates work to a skill,
+     * allowing for tracking skill usage or transforming input to the skill.
+     *
+     * @param event Object containing the skill being used and input message
+     */
+    onSkillStart?: (event: {
+        skill: Agent;
+        input: I;
+    }) => PromiseOrValue<void>;
+    /**
+     * Called after a skill (sub-agent) completes or fails
+     *
+     * This hook runs when a skill finishes execution, receiving either the output
+     * or an error if the skill failed. Useful for monitoring skill performance
+     * or handling skill-specific errors.
+     *
+     * @param event Object containing the skill used, input message, and either output or error
+     */
+    onSkillEnd?: (event: XOr<{
+        skill: Agent;
+        input: I;
+        output: O;
+        error: Error;
+    }, "output", "error">) => PromiseOrValue<void>;
+    /**
+     * Called when an agent hands off processing to another agent
+     *
+     * This hook runs when a source agent transfers control to a target agent,
+     * allowing for tracking of handoffs between agents and monitoring the flow
+     * of processing in multi-agent systems.
+     *
+     * @param event Object containing the source agent, target agent, and input message
+     */
+    onHandoff?: (event: {
+        source: Agent;
+        target: Agent;
+        input: I;
+    }) => PromiseOrValue<void>;
+}
 /**
  * Response type for an agent, can be:
  * - Direct response object
@@ -427,7 +550,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
  *
  * @template T Response data type
  */
-export type AgentResponse<T> = T | TransferAgentOutput | AgentResponseStream<T>;
+export type AgentResponse<T> = T | AgentResponseStream<T> | TransferAgentOutput | GuideRailAgentOutput;
 /**
  * Streaming response type for an agent
  *

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

@@ -1,10 +1,10 @@
 import { type ZodObject, type ZodType, z } from "zod";
 import type { Context } from "../aigne/context.js";
 import { type DefaultMemoryOptions } from "../memory/default-memory.js";
-import { ChatModel } from "../models/chat-model.js";
-import type { ChatModelInput } from "../models/chat-model.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
+import { ChatModel, type ChatModelInput } from "./chat-model.js";
+import type { GuideRailAgentOutput } from "./guide-rail-agent.js";
 /**
  * Configuration options for an AI Agent
  *
@@ -216,6 +216,7 @@ export declare class AIAgent<I extends Message = Message, O extends Message = Me
      * @protected
      */
     process(input: I, context: Context): AgentProcessAsyncGenerator<O>;
+    protected onGuideRailError(error: GuideRailAgentOutput): Promise<O | GuideRailAgentOutput>;
     /**
      * Process router mode requests
      *

package/lib/{cjs/models → dts/agents}/chat-model.d.ts

@@ -1,6 +1,6 @@
-import { Agent, type AgentProcessResult, type Message } from "../agents/agent.js";
 import type { Context } from "../aigne/context.js";
 import type { PromiseOrValue } from "../utils/type-utils.js";
+import { Agent, type AgentProcessResult, type Message } from "./agent.js";
 /**
  * ChatModel is an abstract base class for interacting with Large Language Models (LLMs).
  *
@@ -10,19 +10,19 @@ import type { PromiseOrValue } from "../utils/type-utils.js";
  *
  * @example
  * Here's how to implement a custom ChatModel:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model}
  *
  * @example
  * Here's an example showing streaming response with readable stream:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-streaming}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-streaming}
  *
  * @example
  * Here's an example showing streaming response with async generator:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-streaming-async-generator}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-streaming-async-generator}
  *
  * @example
  * Here's an example with tool calls:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelOutput> {
     constructor();
@@ -44,6 +44,17 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
         supportsParallelToolCalls: boolean;
     };
     private validateToolNames;
+    /**
+     * Normalizes tool names to ensure compatibility with language models
+     *
+     * This method converts tool names to a format that complies with model requirements
+     * by replacing hyphens and whitespace characters with underscores. The normalized
+     * names are used for tool calls while preserving the original names for reference.
+     *
+     * @param name - The original tool name to normalize
+     * @returns A promise that resolves to the normalized tool name
+     */
+    protected normalizeToolName(name: string): Promise<string>;
     /**
      * Performs preprocessing operations before handling input
      *
@@ -53,7 +64,7 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
      * @param context Execution context
      * @throws Error if token usage exceeds maximum limit
      */
-    protected preprocess(input: ChatModelInput, context: Context): void;
+    protected preprocess(input: ChatModelInput, context: Context): Promise<void>;
     /**
      * Performs postprocessing operations after handling output
      *
@@ -94,11 +105,11 @@ export declare abstract class ChatModel extends Agent<ChatModelInput, ChatModelO
  *
  * @example
  * Here's a basic ChatModel input example:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model}
  *
  * @example
  * Here's an example with tool calling:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export interface ChatModelInput extends Message {
     /**
@@ -213,7 +224,7 @@ export type ChatModelInputResponseFormat = {
  *
  * @example
  * Here's an example showing how to use tools:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export interface ChatModelInputTool {
     /**
@@ -249,7 +260,7 @@ export interface ChatModelInputTool {
  *
  * @example
  * Here's an example showing how to use tools:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export type ChatModelInputToolChoice = "auto" | "none" | "required" | {
     type: "function";
@@ -296,11 +307,11 @@ export interface ChatModelOptions {
  *
  * @example
  * Here's a basic output example:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model}
  *
  * @example
  * Here's an example with tool calls:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export interface ChatModelOutput extends Message {
     /**
@@ -331,7 +342,7 @@ export interface ChatModelOutput extends Message {
  *
  * @example
  * Here's an example with tool calls:
- * {@includeCode ../../test/models/chat-model.test.ts#example-chat-model-tools}
+ * {@includeCode ../../test/agents/chat-model.test.ts#example-chat-model-tools}
  */
 export interface ChatModelOutputToolCall {
     /**

package/lib/dts/agents/guide-rail-agent.d.ts

@@ -0,0 +1,62 @@
+import type { Agent, AgentOptions, Message } from "./agent.js";
+/**
+ * Input interface for GuideRail agents
+ *
+ * GuideRail agents receive both input and expected output, allowing them to
+ * validate, transform, or control the flow of messages between other agents.
+ */
+export interface GuideRailAgentInput extends Message {
+    /**
+     * The input data to be processed
+     *
+     * This is the original message that would be sent to the target agent
+     */
+    input?: unknown;
+    /**
+     * The expected output data
+     *
+     * This is what the target agent is expected to produce, allowing
+     * the GuideRail agent to validate or transform the data flow
+     */
+    output?: unknown;
+}
+/**
+ * Output interface for GuideRail agents
+ *
+ * GuideRail agents can either allow the process to continue or abort it with a reason.
+ * This provides a mechanism for enforcing rules, validating data, and controlling
+ * the execution flow of the agent system.
+ */
+export interface GuideRailAgentOutput extends Message {
+    /**
+     * Whether to abort the current process
+     *
+     * When true, the agent system should stop the current execution flow
+     * and prevent further processing based on this input/output pair
+     *
+     * @default false
+     */
+    abort?: boolean;
+    /**
+     * Reason for aborting the process
+     *
+     * When abort is true, this provides a human-readable explanation
+     * for why the process was stopped
+     */
+    reason?: string;
+}
+/**
+ * GuideRail agent type definition
+ *
+ * GuideRail agents act as validators, transformers, or controllers for the message
+ * flow between agents. They can enforce rules, perform safety checks, ensure data
+ * quality, or implement business logic validations.
+ *
+ * Use GuideRail agents when you need to:
+ * - Validate inputs or outputs against specific criteria
+ * - Enforce security or safety policies
+ * - Implement business rules that control agent interactions
+ * - Monitor and audit agent behavior
+ */
+export type GuideRailAgent = Agent<GuideRailAgentInput, GuideRailAgentOutput>;
+export declare const guideRailAgentOptions: AgentOptions<GuideRailAgentInput, GuideRailAgentOutput>;

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

@@ -1,6 +1,7 @@
 import { Agent, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import { ChatModel } from "../agents/chat-model.js";
 import type { UserAgent } from "../agents/user-agent.js";
-import { ChatModel } from "../models/chat-model.js";
+import { type LoadOptions } from "../loader/index.js";
 import { AIGNEContext, type InvokeOptions } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import type { ContextLimits } from "./usage.js";
@@ -54,7 +55,7 @@ export declare class AIGNE {
      * @param options - Options to override the loaded configuration.
      * @returns A fully initialized AIGNE instance with configured agents and skills.
      */
-    static load(path: string, options?: AIGNEOptions): Promise<AIGNE>;
+    static load(path: string, options: AIGNEOptions & Pick<LoadOptions, "models">): Promise<AIGNE>;
     /**
      * Creates a new AIGNE instance with the specified options.
      *

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

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { Agent, type AgentInvokeOptions, type AgentProcessAsyncGenerator, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { ChatModel } from "../agents/chat-model.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";
@@ -41,6 +41,7 @@ export type ContextEmitEventMap = {
 export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
+    sourceAgent?: Agent;
 }
 /**
  * @hidden

package/lib/dts/index.d.ts

@@ -5,6 +5,6 @@ export * from "./agents/team-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";
-export * from "./models/chat-model.js";
+export * from "./agents/chat-model.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

@@ -14,13 +14,13 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
-    toolChoice?: AIAgentToolChoice | undefined;
     outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
     outputKey?: string | undefined;
+    toolChoice?: AIAgentToolChoice | undefined;
 } | {
     type: "mcp";
     url?: string | undefined;