@aigne/core 1.15.0 → 1.17.0

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

@@ -1,7 +1,7 @@
 import { ReadableStream } from "node:stream/web";
 import type { Context } from "../aigne/context.js";
 import { type MessagePayload } from "../aigne/message-queue.js";
-import { Agent, type AgentOptions, type AgentProcessResult, type FunctionAgentFn, type Message } from "./agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type FunctionAgentFn, type Message } from "./agent.js";
 export interface UserAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     context: Context;
     process?: FunctionAgentFn<I, O>;
@@ -14,14 +14,14 @@ export declare class UserAgent<I extends Message = Message, O extends Message =
     private _process?;
     private activeAgent?;
     protected subscribeToTopics(context: Pick<Context, "subscribe">): void;
-    protected publishToTopics(output: O, context: Context): Promise<void>;
+    protected publishToTopics(output: O, options: AgentInvokeOptions): Promise<void>;
     invoke: Agent<I, O>["invoke"];
-    process(input: I, context: Context): Promise<AgentProcessResult<O>>;
+    process(input: I, options: AgentInvokeOptions): Promise<AgentProcessResult<O>>;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];
     get stream(): ReadableStream<MessagePayload & {
         topic: string;
     }>;
-    protected checkAgentInvokesUsage(_context: Context): void;
+    protected checkAgentInvokesUsage(_options: AgentInvokeOptions): void;
 }

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

@@ -1,7 +1,8 @@
 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 { AIGNEContext, type InvokeOptions } from "./context.js";
+import { type LoadOptions } from "../loader/index.js";
+import { AIGNEContext, type Context, type InvokeOptions, type UserContext } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 import type { ContextLimits } from "./usage.js";
 /**
@@ -45,7 +46,7 @@ export interface AIGNEOptions {
  * Here's an example of how to use AIGNE with streaming response:
  * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
  */
-export declare class AIGNE {
+export declare class AIGNE<U extends UserContext = UserContext> {
     /**
      * Loads an AIGNE instance from a directory containing an aigne.yaml file and agent definitions.
      * This static method provides a convenient way to initialize an AIGNE system from configuration files.
@@ -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.
      *
@@ -110,7 +111,7 @@ export declare class AIGNE {
      *
      * @returns A new AIGNEContext instance bound to this AIGNE.
      */
-    newContext(): AIGNEContext;
+    newContext(options?: Partial<Context>): AIGNEContext;
     /**
      * Creates a user agent for consistent interactions with a specified agent.
      * This method allows you to create a wrapper around an agent for repeated invocations.
@@ -133,7 +134,7 @@ export declare class AIGNE {
      * @param options.streaming - Must be false to return a response stream
      * @returns A promise resolving to a tuple containing the agent's response and the final active agent
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions<U> & {
         returnActiveAgent: true;
         streaming?: false;
     }): Promise<[O, Agent]>;
@@ -147,7 +148,7 @@ export declare class AIGNE {
      * @param options.streaming - Must be true to return a response stream
      * @returns A promise resolving to a tuple containing the agent's response stream and a promise for the final agent
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions<U> & {
         returnActiveAgent: true;
         streaming: true;
     }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
@@ -164,7 +165,7 @@ export declare class AIGNE {
      * Here's a simple example of how to invoke an agent:
      * {@includeCode ../../test/aigne/aigne.test.ts#example-simple}
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options?: InvokeOptions<U> & {
         returnActiveAgent?: false;
         streaming?: false;
     }): Promise<O>;
@@ -181,7 +182,7 @@ export declare class AIGNE {
      * Here's an example of how to invoke an agent with streaming response:
      * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
      */
-    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions & {
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message: I | string, options: InvokeOptions<U> & {
         returnActiveAgent?: false;
         streaming: true;
     }): Promise<AgentResponseStream<O>>;
@@ -195,7 +196,7 @@ export declare class AIGNE {
      * @returns Either a UserAgent (when no message provided) or a promise resolving to the agent's response
      * with optional active agent information based on the provided options
      */
-    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]>;
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>, message?: I | string, options?: InvokeOptions<U>): UserAgent<I, O> | Promise<AgentResponse<O> | [AgentResponse<O>, Agent]>;
     /**
      * Publishes a message to the message queue for inter-agent communication.
      * This method broadcasts a message to all subscribers of the specified topic(s).
@@ -203,12 +204,13 @@ export declare class AIGNE {
      *
      * @param topic - The topic or array of topics to publish the message to
      * @param payload - The message payload to be delivered to subscribers
+     * @param options - Optional configuration parameters for the publish operation
      *
      * @example
      * Here's an example of how to publish a message:
      * {@includeCode ../../test/aigne/aigne.test.ts#example-publish-message}
      */
-    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string, options?: InvokeOptions<U>): void;
     /**
      * Subscribes to receive the next message on a specific topic.
      * This overload returns a Promise that resolves with the next message published to the topic.

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";
@@ -38,19 +38,27 @@ export type ContextEmitEventMap = {
 /**
  * @hidden
  */
-export interface InvokeOptions extends AgentInvokeOptions {
+export interface InvokeOptions<U extends UserContext = UserContext> extends Partial<Omit<AgentInvokeOptions<U>, "context">> {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
+    sourceAgent?: Agent;
+    userContext?: U;
 }
 /**
  * @hidden
  */
-export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
+export interface UserContext extends Record<string, unknown> {
+}
+/**
+ * @hidden
+ */
+export interface Context<U extends UserContext = UserContext> extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     skills?: Agent[];
     usage: ContextUsage;
     limits?: ContextLimits;
     status?: "normal" | "timeout";
+    userContext: U;
     /**
      * Create a user agent to consistently invoke an agent
      * @param agent Agent to invoke
@@ -91,7 +99,7 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
      * @param topic topic name, or an array of topic names
      * @param payload message to publish
      */
-    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string, options?: InvokeOptions): void;
     subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
     subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
     subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
@@ -113,15 +121,17 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
  * @hidden
  */
 export declare class AIGNEContext implements Context {
-    constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
+    constructor(...[parent, ...args]: ConstructorParameters<typeof AIGNEContextShared>);
     parentId?: string;
     id: string;
-    readonly internal: AIGNEContextInternal;
+    readonly internal: AIGNEContextShared;
     get model(): ChatModel | undefined;
     get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     get status(): "normal" | "timeout";
     get usage(): ContextUsage;
+    get userContext(): Context["userContext"];
+    set userContext(userContext: Context["userContext"]);
     newContext({ reset }?: {
         reset?: boolean;
     }): AIGNEContext;
@@ -134,17 +144,18 @@ export declare class AIGNEContext 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 AIGNEContextInternal {
+declare class AIGNEContextShared {
     private readonly parent?;
     constructor(parent?: (Pick<Context, "model" | "skills" | "limits"> & {
         messageQueue?: MessageQueue;
-    }) | undefined);
+    }) | undefined, overrides?: Partial<Context>);
     readonly messageQueue: MessageQueue;
     readonly events: EventEmitter<ContextEventMap>;
     get model(): ChatModel | undefined;
     get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;
     usage: ContextUsage;
+    userContext: Context["userContext"];
     private abortController;
     private timer?;
     private initTimeout;

package/lib/dts/index.d.ts

@@ -1,10 +1,11 @@
 export * from "./agents/agent.js";
 export * from "./agents/ai-agent.js";
+export * from "./agents/chat-model.js";
+export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 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 "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

@@ -14,16 +14,16 @@ 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;
-    command?: string | undefined;
     args?: string[] | undefined;
+    command?: string | undefined;
 }>;

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

@@ -1,7 +1,14 @@
+import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
 export interface LoadOptions {
+    models: {
+        new (parameters: {
+            model?: string;
+            modelOptions?: ChatModelOptions;
+        }): ChatModel;
+    }[];
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<{
@@ -15,12 +22,12 @@ export declare function load(options: LoadOptions): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
-export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+export declare function loadModel(models: LoadOptions["models"], model?: Camelize<z.infer<typeof aigneFileSchema>["chat_model"]>, modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -29,35 +36,35 @@ declare const aigneFileSchema: z.ZodObject<{
         name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequency_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     }>]>>>, {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined, string | {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined>;
     agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
@@ -71,7 +78,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -84,7 +91,7 @@ declare const aigneFileSchema: z.ZodObject<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;
@@ -98,7 +105,7 @@ export declare function loadAIGNEFile(path: string): Promise<{
         temperature?: number | null | undefined;
         provider?: string | null | undefined;
         top_p?: number | null | undefined;
-        frequent_penalty?: number | null | undefined;
+        frequency_penalty?: number | null | undefined;
         presence_penalty?: number | null | undefined;
     } | null | undefined;
     agents?: string[] | null | undefined;

package/lib/dts/memory/default-memory/default-memory-storage/index.d.ts

@@ -0,0 +1,30 @@
+import type { AgentInvokeOptions } from "../../../agents/agent.js";
+import "sqlite3";
+import { Sequelize } from "sequelize";
+import type { Context } from "../../../aigne/context.js";
+import type { PromiseOrValue } from "../../../utils/type-utils.js";
+import type { Memory } from "../../memory.js";
+import { MemoryStorage } from "../storage.js";
+export interface DefaultMemoryStorageOptions {
+    path?: string;
+    getSessionId?: (context: Context) => PromiseOrValue<string>;
+}
+export declare class DefaultMemoryStorage extends MemoryStorage {
+    options?: DefaultMemoryStorageOptions | undefined;
+    memories: {
+        [groupId: string]: Memory[];
+    };
+    constructor(options?: DefaultMemoryStorageOptions | undefined);
+    private _models?;
+    private get models();
+    private convertMemory;
+    search(query: {
+        limit?: number;
+    }, { context }: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">, { context }: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+}
+export declare function initSequelize(path?: string): Sequelize;

package/lib/dts/memory/default-memory/default-memory-storage/migrate.d.ts

@@ -0,0 +1,7 @@
+import type { Sequelize } from "sequelize";
+import { type MigrateDownOptions, type MigrateUpOptions } from "umzug";
+export declare const migrate: (sequelize: Sequelize, { type, upOptions, downOptions, }?: {
+    type?: "up" | "down";
+    upOptions?: MigrateUpOptions;
+    downOptions?: MigrateDownOptions;
+}) => Promise<void>;

package/lib/dts/memory/default-memory/default-memory-storage/migrations/20250523165801-init.d.ts

@@ -0,0 +1,7 @@
+import { type QueryInterface } from "sequelize";
+export declare const up: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;
+export declare const down: ({ context: queryInterface }: {
+    context: QueryInterface;
+}) => Promise<void>;

package/lib/dts/memory/default-memory/default-memory-storage/models/memory.d.ts

@@ -0,0 +1,10 @@
+import { type CreationOptional, type InferAttributes, type InferCreationAttributes, Model } from "sequelize";
+import type { ModelStatic, Sequelize } from "sequelize";
+export interface Memory extends Model<InferAttributes<Memory>, InferCreationAttributes<Memory>> {
+    id: CreationOptional<string>;
+    createdAt: CreationOptional<Date>;
+    updatedAt: CreationOptional<Date>;
+    sessionId?: string | null;
+    content: unknown;
+}
+export declare function initMemoryModel(sequelize: Sequelize): ModelStatic<Memory>;

package/lib/dts/memory/default-memory/index.d.ts

@@ -0,0 +1,10 @@
+import { MemoryAgent, type MemoryAgentOptions } from "../memory.js";
+import { type DefaultMemoryStorageOptions } from "./default-memory-storage/index.js";
+import { MemoryStorage } from "./storage.js";
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
+    storage?: MemoryStorage | DefaultMemoryStorageOptions;
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: MemoryStorage;
+}

package/lib/dts/memory/default-memory/storage.d.ts

@@ -0,0 +1,13 @@
+import type { AgentInvokeOptions } from "../../agents/agent.js";
+import type { Memory } from "../memory.js";
+export declare abstract class MemoryStorage {
+    abstract create(memory: Pick<Memory, "content">, options: AgentInvokeOptions): Promise<{
+        result: Memory;
+    }>;
+    abstract search(query: {
+        search?: string;
+        limit?: number;
+    }, options: AgentInvokeOptions): Promise<{
+        result: Memory[];
+    }>;
+}

package/lib/dts/memory/memory.d.ts

@@ -1,10 +1,11 @@
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, type AgentOptions, type Message } from "../agents/agent.js";
 import type { Context } from "../aigne/context.js";
 import type { MessagePayload } from "../aigne/message-queue.js";
 import type { MemoryRecorder, MemoryRecorderInput, MemoryRecorderOutput } from "./recorder.js";
 import type { MemoryRetriever, MemoryRetrieverInput, MemoryRetrieverOutput } from "./retriever.js";
 export interface Memory {
     id: string;
+    sessionId?: string | null;
     content: unknown;
     createdAt: string;
 }
@@ -62,7 +63,7 @@ export declare class MemoryAgent extends Agent {
      * MemoryAgent doesn't directly process messages like other agents, so this method
      * throws an error when called. Use the specialized retrieve() and record() methods instead.
      */
-    process(_input: Message, _context: Context): Promise<Message>;
+    process(_input: Message, _options: AgentInvokeOptions): Promise<Message>;
     /**
      * Retrieves memories based on the provided input criteria.
      *

package/lib/dts/memory/retriever.d.ts

@@ -39,11 +39,11 @@ export declare const memoryRetrieverInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     search: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
     search?: string | undefined;
-}, {
     limit?: number | undefined;
+}, {
     search?: string | undefined;
+    limit?: number | undefined;
 }>;
 /**
  * @hidden

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

@@ -1,17 +1,23 @@
 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 { ChatModel, ChatModelInput } from "../agents/chat-model.js";
 import type { Context } from "../aigne/context.js";
 import type { MemoryAgent } from "../memory/memory.js";
-import type { ChatModel, ChatModelInput } from "../models/chat-model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
-export declare function createMessage<I extends Message>(message: string | I): I;
+export declare function createMessage<V extends Message>(message: string, variables?: V): {
+    [MESSAGE_KEY]: string;
+} & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: I, variables?: V): I & typeof variables;
+export declare function createMessage<I extends Message, V extends Message>(message: string | I, variables?: V): ({
+    [MESSAGE_KEY]: string;
+} | I) & typeof variables;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuilderBuildOptions {
+export interface PromptBuildOptions {
     memory?: MemoryAgent | MemoryAgent[];
     context: Context;
     agent?: AIAgent;
@@ -32,7 +38,7 @@ export declare class PromptBuilder {
     private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
-    build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
     private buildMessages;

package/lib/dts/prompt/template.d.ts

@@ -1,4 +1,4 @@
-import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../models/chat-model.js";
+import type { ChatModelInputMessage, ChatModelInputMessageContent, ChatModelOutputToolCall } from "../agents/chat-model.js";
 export declare class PromptTemplate {
     template: string;
     static from(template: string): PromptTemplate;
@@ -24,7 +24,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCalls: ChatModelOutputToolCall[] | undefined;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCallId?: string;
         name?: string;
@@ -36,7 +36,7 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content: object | string, toolCallId: string, name?: string);
     format(variables?: Record<string, unknown>): {
         toolCallId: string;
-        role: import("../models/chat-model.js").Role;
+        role: import("../agents/chat-model.js").Role;
         content?: ChatModelInputMessageContent;
         toolCalls?: {
             id: string;

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

@@ -1,8 +1,33 @@
-import debug from "debug";
-export declare const logger: debug.Debug & {
-    debug: debug.Debug;
-    default: debug.Debug;
-} & {
-    core: debug.Debugger;
-    mcp: debug.Debugger;
-};
+export declare enum LogLevel {
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug"
+}
+export declare class Logger {
+    constructor(options: {
+        level: LogLevel;
+        ns: string;
+    });
+    level: LogLevel;
+    private debugLogger;
+    private infoLogger;
+    private warnLogger;
+    private errorLogger;
+    logMessage: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    logError: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    enabled(level: LogLevel): boolean;
+}
+export declare const logger: Logger;

package/lib/dts/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/dts/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/dts/utils/type-utils.d.ts

@@ -1,7 +1,12 @@
-import { type ZodType } from "zod";
+import { type ZodType, z } 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;
@@ -15,6 +20,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 | unknown): T;
+export declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<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;