@aigne/core 1.13.0 → 1.14.0

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

@@ -1,38 +1,285 @@
-import { Agent } from "../agents/agent.js";
+import { Agent, type AgentResponse, type AgentResponseStream, type Message } from "../agents/agent.js";
+import type { UserAgent } from "../agents/user-agent.js";
 import { ChatModel } from "../models/chat-model.js";
-import { AIGNEContext, type Context } from "./context.js";
-import { MessageQueue } from "./message-queue.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";
+/**
+ * Options for the AIGNE class.
+ */
 export interface AIGNEOptions {
+    /**
+     * The name of the AIGNE instance.
+     */
     name?: string;
+    /**
+     * The description of the AIGNE instance.
+     */
     description?: string;
+    /**
+     * Global model to use for all agents not specifying a model.
+     */
     model?: ChatModel;
+    /**
+     * Skills to use for the AIGNE instance.
+     */
     skills?: Agent[];
+    /**
+     * Agents to use for the AIGNE instance.
+     */
     agents?: Agent[];
+    /**
+     * Limits for the AIGNE instance, such as timeout, max tokens, max invocations, etc.
+     */
     limits?: ContextLimits;
 }
+/**
+ * AIGNE is a class that orchestrates multiple agents to build complex AI applications.
+ * It serves as the central coordination point for agent interactions, message passing, and execution flow.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNE:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-simple}
+ *
+ * @example
+ * Here's an example of how to use AIGNE with streaming response:
+ * {@includeCode ../../test/aigne/aigne.test.ts#example-streaming}
+ */
 export declare class AIGNE {
-    static load({ path, ...options }: {
-        path: string;
-    } & AIGNEOptions): Promise<AIGNE>;
+    /**
+     * 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.
+     *
+     * @param path - Path to the directory containing the aigne.yaml file.
+     * @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>;
+    /**
+     * Creates a new AIGNE instance with the specified options.
+     *
+     * @param options - Configuration options for the AIGNE instance including name, description, model, and agents.
+     */
     constructor(options?: AIGNEOptions);
+    /**
+     * Optional name identifier for this AIGNE instance.
+     */
     name?: string;
+    /**
+     * Optional description of this AIGNE instance's purpose or functionality.
+     */
     description?: string;
-    readonly messageQueue: MessageQueue;
+    /**
+     * Global model to use for all agents that don't specify their own model.
+     */
     model?: ChatModel;
-    readonly skills: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
-        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
+    /**
+     * Usage limits applied to this AIGNE instance's execution.
+     */
+    limits?: ContextLimits;
+    /**
+     * Message queue for handling inter-agent communication.
+     *
+     * @hidden
+     */
+    readonly messageQueue: MessageQueue;
+    /**
+     * Collection of skill agents available to this AIGNE instance.
+     * Provides indexed access by skill name.
+     */
+    readonly skills: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
     };
-    readonly agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[] & {
-        [key: string]: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>;
+    /**
+     * Collection of primary agents managed by this AIGNE instance.
+     * Provides indexed access by agent name.
+     */
+    readonly agents: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
     };
-    limits?: ContextLimits;
+    /**
+     * Adds one or more agents to this AIGNE instance.
+     * Each agent is attached to this AIGNE instance, allowing it to access the AIGNE's resources.
+     *
+     * @param agents - One or more Agent instances to add to this AIGNE.
+     */
     addAgent(...agents: Agent[]): void;
+    /**
+     * Creates a new execution context for this AIGNE instance.
+     * Contexts isolate state for different flows or conversations.
+     *
+     * @returns A new AIGNEContext instance bound to this AIGNE.
+     */
     newContext(): AIGNEContext;
-    publish: Context["publish"];
-    invoke: Context["invoke"];
-    subscribe: Context["subscribe"];
-    unsubscribe: Context["unsubscribe"];
+    /**
+     * 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.
+     *
+     * @param agent - Target agent to be wrapped for consistent invocation
+     * @returns A user agent instance that provides a convenient interface for interacting with the target agent
+     *
+     * @example
+     * Here's an example of how to create a user agent and invoke it consistently:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-user-agent}
+     */
+    invoke<I extends Message, O extends Message>(agent: Agent<I, O>): UserAgent<I, O>;
+    /**
+     * Invokes an agent with a message and returns both the output and the active agent.
+     * This overload is useful when you need to track which agent was ultimately responsible for generating the response.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options.returnActiveAgent - Must be true to return the final active agent
+     * @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 & {
+        returnActiveAgent: true;
+        streaming?: false;
+    }): Promise<[O, Agent]>;
+    /**
+     * Invokes an agent with a message and returns both a stream of the response and the active agent.
+     * This overload is useful when you need streaming responses while also tracking which agent provided them.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options.returnActiveAgent - Must be true to return the final active agent
+     * @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 & {
+        returnActiveAgent: true;
+        streaming: true;
+    }): Promise<[AgentResponseStream<O>, Promise<Agent>]>;
+    /**
+     * Invokes an agent with a message and returns just the output.
+     * This is the standard way to invoke an agent when you only need the response.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options - Optional configuration parameters for the invocation
+     * @returns A promise resolving to the agent's complete response
+     *
+     * @example
+     * 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 & {
+        returnActiveAgent?: false;
+        streaming?: false;
+    }): Promise<O>;
+    /**
+     * Invokes an agent with a message and returns a stream of the response.
+     * This allows processing the response incrementally as it's being generated.
+     *
+     * @param agent - Target agent to invoke
+     * @param message - Input message to send to the agent (can be a string or a structured message object)
+     * @param options - Configuration with streaming enabled to receive incremental response chunks
+     * @returns A promise resolving to a stream of the agent's response that can be consumed incrementally
+     *
+     * @example
+     * 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 & {
+        returnActiveAgent?: false;
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    /**
+     * General implementation signature that handles all overload cases.
+     * This unified signature supports all the different invocation patterns defined by the overloads.
+     *
+     * @param agent - Target agent to invoke or wrap
+     * @param message - Optional input message to send to the agent
+     * @param options - Optional configuration parameters for the invocation
+     * @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]>;
+    /**
+     * Publishes a message to the message queue for inter-agent communication.
+     * This method broadcasts a message to all subscribers of the specified topic(s).
+     * It creates a new context internally and delegates to the context's publish method.
+     *
+     * @param topic - The topic or array of topics to publish the message to
+     * @param payload - The message payload to be delivered to subscribers
+     *
+     * @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;
+    /**
+     * 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.
+     * It's useful for one-time message handling or when using async/await patterns.
+     *
+     * @param topic - The topic to subscribe to
+     * @returns A Promise that resolves with the next message payload published to the specified topic
+     *
+     * @example
+     * Here's an example of how to subscribe to a topic and receive the next message:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-publish-message}
+     */
+    subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
+    /**
+     * Subscribes to messages on a specific topic with a listener callback.
+     * This overload registers a listener function that will be called for each message published to the topic.
+     * It's useful for continuous message handling or event-driven architectures.
+     *
+     * @param topic - The topic to subscribe to
+     * @param listener - Callback function that will be invoked when messages arrive on the specified topic
+     * @returns An Unsubscribe function that can be called to cancel the subscription
+     *
+     * @example
+     * Here's an example of how to subscribe to a topic with a listener:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-subscribe-topic}
+     */
+    subscribe(topic: string | string[], listener: MessageQueueListener): Unsubscribe;
+    /**
+     * Generic subscribe signature that handles both Promise and listener patterns.
+     * This is the implementation signature that supports both overloaded behaviors.
+     *
+     * @param topic - The topic to subscribe to
+     * @param listener - Optional callback function
+     * @returns Either a Promise for the next message or an Unsubscribe function
+     */
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    /**
+     * Unsubscribes a listener from a specific topic in the message queue.
+     * This method stops a previously registered listener from receiving further messages.
+     * It should be called when message processing is complete or when the component is no longer interested
+     * in messages published to the specified topic.
+     *
+     * @param topic - The topic to unsubscribe from
+     * @param listener - The listener function that was previously subscribed to the topic
+     *
+     * @example
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-subscribe-topic}
+     */
+    unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
+    /**
+     * Gracefully shuts down the AIGNE instance and all its agents and skills.
+     * This ensures proper cleanup of resources before termination.
+     *
+     * @returns A promise that resolves when shutdown is complete.
+     *
+     * @example
+     * Here's an example of shutdown an AIGNE instance:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown}
+     */
     shutdown(): Promise<void>;
+    /**
+     * Asynchronous dispose method for the AIGNE instance.
+     *
+     * @example
+     * Here's an example of using async dispose:
+     * {@includeCode ../../test/aigne/aigne.test.ts#example-shutdown-using}
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Initializes handlers for process exit events to ensure clean shutdown.
+     * This registers handlers for SIGINT and exit events to properly terminate all agents.
+     */
     private initProcessExitHandler;
 }

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

@@ -6,12 +6,18 @@ 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";
+/**
+ * @hidden
+ */
 export interface AgentEvent {
     parentContextId?: string;
     contextId: string;
     timestamp: number;
     agent: Agent;
 }
+/**
+ * @hidden
+ */
 export interface ContextEventMap {
     agentStarted: [AgentEvent & {
         input: Message;
@@ -23,13 +29,22 @@ export interface ContextEventMap {
         error: Error;
     }];
 }
+/**
+ * @hidden
+ */
 export type ContextEmitEventMap = {
     [K in keyof ContextEventMap]: OmitPropertiesFromArrayFirstElement<ContextEventMap[K], "contextId" | "parentContextId" | "timestamp">;
 };
+/**
+ * @hidden
+ */
 export interface InvokeOptions extends AgentInvokeOptions {
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
 }
+/**
+ * @hidden
+ */
 export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitEventMap> {
     model?: ChatModel;
     skills?: Agent[];
@@ -76,12 +91,12 @@ 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">): void;
-    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string, listener: MessageQueueListener): void;
+    publish(topic: string | string[], payload: Omit<MessagePayload, "context"> | Message | string): 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>;
+    subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
+    unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
     /**
      * Create a child context with the same configuration as the parent context.
      * If `reset` is true, the child context will have a new state (such as: usage).
@@ -94,7 +109,9 @@ export interface Context extends TypedEventEmitter<ContextEventMap, ContextEmitE
         reset?: boolean;
     }): Context;
 }
-export declare function createPublishMessage(message: string | Message, from?: Agent): Omit<MessagePayload, "context">;
+/**
+ * @hidden
+ */
 export declare class AIGNEContext implements Context {
     constructor(parent?: ConstructorParameters<typeof AIGNEContextInternal>[0]);
     parentId?: string;
@@ -109,7 +126,6 @@ export declare class AIGNEContext implements Context {
         reset?: boolean;
     }): AIGNEContext;
     invoke: Context["invoke"];
-    private onInvokeSuccess;
     publish: Context["publish"];
     subscribe: Context["subscribe"];
     unsubscribe: Context["unsubscribe"];

package/lib/dts/aigne/message-queue.d.ts

@@ -1,22 +1,44 @@
 import { EventEmitter } from "node:events";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
+/**
+ * @hidden
+ */
 export declare const UserInputTopic = "UserInputTopic";
+/**
+ * @hidden
+ */
 export declare const UserOutputTopic = "UserOutputTopic";
+/**
+ * @hidden
+ */
 export interface MessagePayload {
     role: "user" | "agent";
     source?: string;
     message: Message;
     context: Context;
 }
+/**
+ * @hidden
+ */
+export declare function toMessagePayload(payload: Omit<MessagePayload, "context"> | string | Message, options?: Partial<Pick<MessagePayload, "role" | "source">>): Omit<MessagePayload, "context">;
+/**
+ * @hidden
+ */
 export type MessageQueueListener = (message: MessagePayload) => void;
+/**
+ * @hidden
+ */
 export type Unsubscribe = () => void;
+/**
+ * @hidden
+ */
 export declare class MessageQueue {
     events: EventEmitter<[never]>;
     publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
-    subscribe(topic: string, listener?: undefined): Promise<MessagePayload>;
-    subscribe(topic: string, listener: MessageQueueListener): Unsubscribe;
-    subscribe(topic: string, listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
-    unsubscribe(topic: string, listener: MessageQueueListener): 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>;
+    unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
 }

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

@@ -1,9 +1,18 @@
+/**
+ * @hidden
+ */
 export interface ContextUsage {
     inputTokens: number;
     outputTokens: number;
     agentCalls: number;
 }
+/**
+ * @hidden
+ */
 export declare function newEmptyContextUsage(): ContextUsage;
+/**
+ * @hidden
+ */
 export interface ContextLimits {
     maxTokens?: number;
     maxAgentInvokes?: number;

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

@@ -1,19 +1,97 @@
+/**
+ * Client module used to interact with the AIGNE framework.
+ */
 import type { AgentInvokeOptions, AgentResponse, AgentResponseStream, Message } from "../agents/agent.js";
+/**
+ * Configuration options for the AIGNEClient.
+ */
 export interface AIGNEClientOptions {
+    /**
+     * The URL of the AIGNE server to connect to.
+     * This should point to the base endpoint where the AIGNEServer is hosted.
+     */
     url: string;
 }
+/**
+ * Options for invoking an agent through the AIGNEClient.
+ * Extends the standard AgentInvokeOptions with client-specific options.
+ */
 export interface AIGNEClientInvokeOptions extends AgentInvokeOptions {
+    /**
+     * Additional fetch API options to customize the HTTP request.
+     * These options will be merged with the default options used by the client.
+     */
     fetchOptions?: Partial<RequestInit>;
 }
+/**
+ * Client for interacting with a remote AIGNE server.
+ * AIGNEClient provides a client-side interface that matches the AIGNE API,
+ * allowing applications to invoke agents and receive responses from a remote AIGNE instance.
+ *
+ * @example
+ * Here's a simple example of how to use AIGNEClient:
+ * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
+ *
+ * @example
+ * Here's an example of how to use AIGNEClient with streaming response:
+ * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
+ */
 export declare class AIGNEClient {
     options: AIGNEClientOptions;
+    /**
+     * Creates a new AIGNEClient instance.
+     *
+     * @param options - Configuration options for connecting to the AIGNE server
+     */
     constructor(options: AIGNEClientOptions);
-    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
-        streaming: true;
-    }): Promise<AgentResponseStream<O>>;
+    /**
+     * Invokes an agent in non-streaming mode and returns the complete response.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options with streaming mode explicitly set to false or omitted
+     * @returns The complete agent response
+     *
+     * @example
+     * Here's a simple example of how to use AIGNEClient:
+     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-simple}
+     */
     invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions & {
         streaming?: false;
     }): Promise<O>;
+    /**
+     * Invokes an agent with streaming mode enabled and returns a stream of response chunks.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options with streaming mode explicitly set to true
+     * @returns A stream of agent response chunks
+     *
+     * @example
+     * Here's an example of how to use AIGNEClient with streaming response:
+     * {@includeCode ../../test/client/client.test.ts#example-aigne-client-streaming}
+     */
+    invoke<I extends Message, O extends Message>(agent: string, input: I, options: AIGNEClientInvokeOptions & {
+        streaming: true;
+    }): Promise<AgentResponseStream<O>>;
+    /**
+     * Invokes an agent with the given input and options.
+     *
+     * @param agent - Name of the agent to invoke
+     * @param input - Input message for the agent
+     * @param options - Options for the invocation
+     * @returns Either a complete response or a response stream depending on the streaming option
+     */
     invoke<I extends Message, O extends Message>(agent: string, input: I, options?: AIGNEClientInvokeOptions): Promise<AgentResponse<O>>;
+    /**
+     * Enhanced fetch method that handles error responses from the AIGNE server.
+     * This method wraps the standard fetch API to provide better error handling and reporting.
+     *
+     * @param args - Standard fetch API arguments (url and options)
+     * @returns A Response object if the request was successful
+     * @throws Error with detailed information if the request failed
+     *
+     * @private
+     */
     fetch(...args: Parameters<typeof globalThis.fetch>): Promise<Response>;
 }

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

@@ -0,0 +1 @@
+export * from "./client.js";

package/lib/dts/index.d.ts

@@ -1,7 +1,6 @@
 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";

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

@@ -2,7 +2,7 @@ import { type ZodObject, type ZodType, z } from "zod";
 import type { Message } from "../agents/agent.js";
 export declare function loadAgentFromJsFile(path: string): Promise<{
     name: string;
-    fn: (args_0: Message) => Message;
+    process: (args_0: Message) => Message;
     description?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;

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

@@ -1,19 +1,20 @@
 import { type ZodObject, type ZodType, z } from "zod";
+import { AIAgentToolChoice } from "../agents/ai-agent.js";
 export declare function loadAgentFromYamlFile(path: string): Promise<{
     type: "ai";
     name: string;
     description?: string | undefined;
+    skills?: string[] | undefined;
     memory?: true | {
         subscribeTopic?: string[] | undefined;
     } | undefined;
-    skills?: string[] | undefined;
     instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {
         [x: string]: any;
     }> | undefined;
-    toolChoice?: "auto" | "none" | "required" | "router" | undefined;
+    toolChoice?: AIAgentToolChoice | undefined;
     outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

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

@@ -8,8 +8,8 @@ export declare function load(options: LoadOptions): Promise<{
     model: ChatModel | undefined;
     agents: 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;
+    description?: string | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
         temperature?: number | null | undefined;
@@ -63,8 +63,8 @@ declare const aigneFileSchema: z.ZodObject<{
     agents: 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;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;
@@ -76,8 +76,8 @@ declare const aigneFileSchema: z.ZodObject<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }, {
-    description?: string | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     skills?: string[] | null | undefined;
     chat_model?: string | {
         name?: string | null | undefined;
@@ -90,8 +90,8 @@ declare const aigneFileSchema: z.ZodObject<{
     agents?: string[] | null | undefined;
 }>;
 export declare function loadAIGNEFile(path: string): Promise<{
-    description?: string | null | undefined;
     name?: string | null | undefined;
+    description?: string | null | undefined;
     skills?: string[] | null | undefined;
     chat_model?: {
         name?: string | null | undefined;

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

@@ -0,0 +1,16 @@
+import { type Memory, MemoryAgent, type MemoryAgentOptions } from "./memory.js";
+export declare const DEFAULT_MAX_MEMORY_COUNT = 10;
+export interface DefaultMemoryOptions extends Partial<MemoryAgentOptions> {
+}
+export declare class DefaultMemory extends MemoryAgent {
+    constructor(options?: DefaultMemoryOptions);
+    storage: Memory[];
+    search(options?: {
+        limit?: number;
+    }): Promise<{
+        result: Memory[];
+    }>;
+    create(memory: Pick<Memory, "content">): Promise<{
+        result: Memory;
+    }>;
+}

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

@@ -0,0 +1,3 @@
+export * from "./memory.js";
+export * from "./recorder.js";
+export * from "./retriever.js";