@aigne/core 1.17.0 → 1.18.0

package/lib/esm/agents/agent.js

@@ -1,7 +1,7 @@
-import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
-import { createMessage } from "../prompt/prompt-builder.js";
+import { createMessage, getMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
+import { nodejs } from "../utils/nodejs.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
 import { checkArguments, createAccessorArray, isEmpty, orArrayToArray, } from "../utils/type-utils.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
@@ -19,6 +19,7 @@ export const agentOptionsSchema = z.object({
     skills: z.array(z.union([z.custom(), z.custom()])).optional(),
     disableEvents: z.boolean().optional(),
     memory: z.union([z.custom(), z.array(z.custom())]).optional(),
+    maxRetrieveMemoryCount: z.number().optional(),
     hooks: z
         .object({
         onStart: z.custom().optional(),
@@ -75,6 +76,7 @@ export class Agent {
         else if (options.memory) {
             this.memories.push(options.memory);
         }
+        this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
         this.hooks = options.hooks ?? {};
         this.guideRails = options.guideRails;
     }
@@ -82,6 +84,10 @@ export class Agent {
      * List of memories this agent can use
      */
     memories = [];
+    /**
+     * Maximum number of memory items to retrieve
+     */
+    maxRetrieveMemoryCount;
     /**
      * Lifecycle hooks for agent processing.
      *
@@ -262,11 +268,33 @@ export class Agent {
     async newDefaultContext() {
         return import("../aigne/context.js").then((m) => new m.AIGNEContext());
     }
+    async retrieveMemories(input, options) {
+        const memories = [];
+        for (const memory of this.memories) {
+            const ms = (await memory.retrieve({
+                ...input,
+                search: typeof input === "string" ? input : input && getMessage(input),
+                limit: input.limit ?? this.maxRetrieveMemoryCount,
+            }, options.context)).memories;
+            memories.push(...ms);
+        }
+        return memories;
+    }
+    async recordMemories(input, options) {
+        for (const memory of this.memories) {
+            if (memory.autoUpdate) {
+                await memory.record(input, options.context);
+            }
+        }
+    }
     async invoke(input, options = {}) {
         const opts = {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
+        if (options.userContext) {
+            Object.assign(opts.context.userContext, options.userContext);
+        }
         const message = typeof input === "string" ? createMessage(input) : input;
         logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
@@ -440,16 +468,12 @@ export class Agent {
     async postprocess(input, output, options) {
         this.checkContextStatus(options);
         this.publishToTopics(output, options);
-        for (const memory of this.memories) {
-            if (memory.autoUpdate) {
-                await memory.record({
-                    content: [
-                        { role: "user", content: input },
-                        { role: "agent", content: replaceTransferAgentToName(output), source: this.name },
-                    ],
-                }, options.context);
-            }
-        }
+        await this.recordMemories({
+            content: [
+                { role: "user", content: input },
+                { role: "agent", content: replaceTransferAgentToName(output), source: this.name },
+            ],
+        }, options);
     }
     async publishToTopics(output, options) {
         const publishTopics = typeof this.publishTopic === "function" ? await this.publishTopic(output) : this.publishTopic;
@@ -491,7 +515,7 @@ export class Agent {
      *
      * @returns Agent name
      */
-    [inspect.custom]() {
+    [nodejs.customInspect]() {
         return this.name;
     }
     /**

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

@@ -1,5 +1,4 @@
 import { type ZodObject, type ZodType, z } from "zod";
-import { type DefaultMemoryOptions } from "../memory/default-memory/index.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessAsyncGenerator, type Message } from "./agent.js";
 import { ChatModel, type ChatModelInput } from "./chat-model.js";
@@ -13,7 +12,7 @@ import type { GuideRailAgentOutput } from "./guide-rail-agent.js";
  * @template I The input message type the agent accepts
  * @template O The output message type the agent returns
  */
-export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends Omit<AgentOptions<I, O>, "memory"> {
+export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     /**
      * The language model to use for this agent
      *
@@ -65,7 +64,6 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * The template receives a {{memories}} variable containing serialized memory content.
      */
     memoryPromptTemplate?: string;
-    memory?: AgentOptions<I, O>["memory"] | DefaultMemoryOptions | true;
 }
 /**
  * Tool choice options for AI agents

package/lib/esm/agents/ai-agent.js

@@ -1,6 +1,4 @@
 import { z } from "zod";
-import { DefaultMemory } from "../memory/default-memory/index.js";
-import { MemoryAgent } from "../memory/memory.js";
 import { MESSAGE_KEY, PromptBuilder } from "../prompt/prompt-builder.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
 import { checkArguments, isEmpty } from "../utils/type-utils.js";
@@ -98,14 +96,7 @@ export class AIAgent extends Agent {
      * @param options Configuration options for the AI agent
      */
     constructor(options) {
-        super({
-            ...options,
-            memory: !options.memory
-                ? undefined
-                : Array.isArray(options.memory) || options.memory instanceof MemoryAgent
-                    ? options.memory
-                    : new DefaultMemory(options.memory === true ? {} : options.memory),
-        });
+        super(options);
         checkArguments("AIAgent", aiAgentOptionsSchema, options);
         this.model = options.model;
         this.instructions =
@@ -190,10 +181,10 @@ export class AIAgent extends Agent {
         if (!model)
             throw new Error("model is required to run AIAgent");
         const { toolAgents, ...modelInput } = await this.instructions.build({
+            ...options,
             agent: this,
             input,
             model,
-            context: options.context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         if (this.toolChoice === "router") {

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

@@ -1,6 +1,6 @@
 import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
 import { type SSEClientTransportOptions } from "@modelcontextprotocol/sdk/client/sse.js";
-import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { type StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";

package/lib/esm/agents/mcp-agent.js

@@ -1,12 +1,13 @@
+import { createStdioClientTransport } from "@aigne/platform-helpers/mcp/stdio-client-transport.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport, } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
 import pRetry from "p-retry";
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
+import { nodejs } from "../utils/nodejs.js";
 import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { Agent } from "./agent.js";
 const MCP_AGENT_CLIENT_NAME = "AIGNE/MCPAgent";
@@ -16,7 +17,7 @@ const DEFAULT_TIMEOUT = () => z.coerce
     .number()
     .int()
     .min(0)
-    .safeParse(process.env.MCP_TIMEOUT || process.env.TIMEOUT).data || 60e3;
+    .safeParse(nodejs.env.MCP_TIMEOUT || nodejs.env.TIMEOUT).data || 60e3;
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
 }
@@ -60,14 +61,7 @@ export class MCPAgent extends Agent {
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
-            const transport = () => new StdioClientTransport({
-                ...options,
-                env: {
-                    ...getDefaultEnvironment(),
-                    ...options.env,
-                },
-                stderr: "pipe",
-            });
+            const transport = async () => createStdioClientTransport(options);
             return MCPAgent.fromTransport(transport, options);
         }
         return new MCPAgent(options);
@@ -77,7 +71,7 @@ export class MCPAgent extends Agent {
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
         }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
-        const transport = transportCreator();
+        const transport = await transportCreator();
         logger.debug(`Connecting to MCP server: ${getMCPServerString(options)}`);
         await client.connect(transport);
         const mcpServer = getMCPServerName(client);

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

@@ -1,4 +1,3 @@
-import { ReadableStream } from "node:stream/web";
 import type { Context } from "../aigne/context.js";
 import { type MessagePayload } from "../aigne/message-queue.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessResult, type FunctionAgentFn, type Message } from "./agent.js";

package/lib/esm/agents/user-agent.js

@@ -1,4 +1,3 @@
-import { ReadableStream } from "node:stream/web";
 import { toMessagePayload } from "../aigne/message-queue.js";
 import { orArrayToArray } from "../utils/type-utils.js";
 import { Agent, } from "./agent.js";

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

@@ -1,4 +1,4 @@
-import EventEmitter from "node:events";
+import { Emitter } from "strict-event-emitter";
 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";
@@ -42,7 +42,6 @@ export interface InvokeOptions<U extends UserContext = UserContext> extends Part
     returnActiveAgent?: boolean;
     disableTransfer?: boolean;
     sourceAgent?: Agent;
-    userContext?: U;
 }
 /**
  * @hidden
@@ -150,7 +149,7 @@ declare class AIGNEContextShared {
         messageQueue?: MessageQueue;
     }) | undefined, overrides?: Partial<Context>);
     readonly messageQueue: MessageQueue;
-    readonly events: EventEmitter<ContextEventMap>;
+    readonly events: Emitter<any>;
     get model(): ChatModel | undefined;
     get skills(): Agent<Message, Message>[] | undefined;
     get limits(): ContextLimits | undefined;

package/lib/esm/aigne/context.js

@@ -1,4 +1,4 @@
-import EventEmitter from "node:events";
+import { Emitter } from "strict-event-emitter";
 import { v7 } from "uuid";
 import { z } from "zod";
 import { Agent, } from "../agents/agent.js";
@@ -143,7 +143,8 @@ class AIGNEContextShared {
         this.userContext = overrides?.userContext ?? {};
     }
     messageQueue;
-    events = new EventEmitter();
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    events = new Emitter();
     get model() {
         return this.parent?.model;
     }

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

@@ -1,4 +1,4 @@
-import { EventEmitter } from "node:events";
+import { Emitter, type EventMap } from "strict-event-emitter";
 import type { Message } from "../agents/agent.js";
 import type { Context } from "./context.js";
 /**
@@ -30,11 +30,14 @@ export type MessageQueueListener = (message: MessagePayload) => void;
  * @hidden
  */
 export type Unsubscribe = () => void;
+interface MessageQueueEventMap extends EventMap {
+    [key: string]: any[];
+}
 /**
  * @hidden
  */
 export declare class MessageQueue {
-    events: EventEmitter<[never]>;
+    events: Emitter<MessageQueueEventMap>;
     publish(topic: string | string[], payload: MessagePayload): void;
     error(error: Error): void;
     subscribe(topic: string | string[], listener?: undefined): Promise<MessagePayload>;
@@ -42,3 +45,4 @@ export declare class MessageQueue {
     subscribe(topic: string | string[], listener?: MessageQueueListener): Unsubscribe | Promise<MessagePayload>;
     unsubscribe(topic: string | string[], listener: MessageQueueListener): void;
 }
+export {};

package/lib/esm/aigne/message-queue.js

@@ -1,4 +1,4 @@
-import { EventEmitter } from "node:events";
+import { Emitter } from "strict-event-emitter";
 import { z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { checkArguments, isNil, orArrayToArray } from "../utils/type-utils.js";
@@ -36,7 +36,7 @@ export function toMessagePayload(payload, options) {
  * @hidden
  */
 export class MessageQueue {
-    events = new EventEmitter();
+    events = new Emitter();
     publish(topic, payload) {
         checkArguments("MessageQueue.publish", publishArgsSchema, {
             topic,

package/lib/esm/index.d.ts

@@ -7,5 +7,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 "./memory/index.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

package/lib/esm/index.js

@@ -7,5 +7,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 "./memory/index.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";

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

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

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

@@ -5,10 +5,11 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     name: string;
     description?: string | undefined;
     skills?: string[] | undefined;
+    instructions?: string | undefined;
     memory?: true | {
+        provider: string;
         subscribeTopic?: string[] | undefined;
     } | undefined;
-    instructions?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

package/lib/esm/loader/agent-yaml.js

@@ -1,9 +1,9 @@
-import { readFile } from "node:fs/promises";
 import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
 import { parse } from "yaml";
 import { z } from "zod";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { customCamelize } from "../utils/camelize.js";
+import { nodejs } from "../utils/nodejs.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { inputOutputSchema } from "./schema.js";
 const agentFileSchema = z.discriminatedUnion("type", [
@@ -40,6 +40,7 @@ const agentFileSchema = z.discriminatedUnion("type", [
             .union([
             z.boolean(),
             z.object({
+                provider: z.string(),
                 subscribe_topic: z
                     .array(z.string())
                     .nullish()
@@ -66,7 +67,7 @@ const agentFileSchema = z.discriminatedUnion("type", [
     }),
 ]);
 export async function loadAgentFromYamlFile(path) {
-    const raw = await tryOrThrow(() => readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
     const agent = tryOrThrow(() => customCamelize(agentFileSchema.parse({
         ...json,

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

@@ -2,6 +2,7 @@ import type { Camelize } from "camelize-ts";
 import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
 import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
+import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
 export interface LoadOptions {
     models: {
         new (parameters: {
@@ -9,6 +10,9 @@ export interface LoadOptions {
             modelOptions?: ChatModelOptions;
         }): ChatModel;
     }[];
+    memories?: {
+        new (parameters?: MemoryAgentOptions): MemoryAgent;
+    }[];
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<{
@@ -26,7 +30,7 @@ export declare function load(options: LoadOptions): Promise<{
         presence_penalty?: number | null | undefined;
     } | null | undefined;
 }>;
-export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadAgent(path: string, options?: LoadOptions): Promise<Agent>;
 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>>;

package/lib/esm/loader/index.js

@@ -1,21 +1,19 @@
-import { readFile, stat } from "node:fs/promises";
-import { dirname, extname, join } from "node:path";
 import { parse } from "yaml";
 import { z } from "zod";
 import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
+import { nodejs } from "../utils/nodejs.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
 import { loadAgentFromYamlFile } from "./agent-yaml.js";
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 export async function load(options) {
-    const { path } = options;
-    const aigneFilePath = await getAIGNEFilePath(path);
-    const rootDir = dirname(aigneFilePath);
+    const aigneFilePath = await getAIGNEFilePath(options.path);
+    const rootDir = nodejs.path.dirname(aigneFilePath);
     const aigne = await loadAIGNEFile(aigneFilePath);
-    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(join(rootDir, filename))));
-    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(nodejs.path.join(rootDir, filename))));
+    const skills = await Promise.all((aigne.skills ?? []).map((filename) => loadAgent(nodejs.path.join(rootDir, filename))));
     return {
         ...aigne,
         model: await loadModel(options.models, aigne.chat_model),
@@ -23,18 +21,21 @@ export async function load(options) {
         skills,
     };
 }
-export async function loadAgent(path) {
-    if (extname(path) === ".js") {
+export async function loadAgent(path, options) {
+    if (nodejs.path.extname(path) === ".js") {
         const agent = await loadAgentFromJsFile(path);
         return FunctionAgent.from(agent);
     }
-    if (extname(path) === ".yaml" || extname(path) === ".yml") {
+    if (nodejs.path.extname(path) === ".yaml" || nodejs.path.extname(path) === ".yml") {
         const agent = await loadAgentFromYamlFile(path);
         if (agent.type === "ai") {
             return AIAgent.from({
                 ...agent,
+                memory: !options?.memories?.length || !agent.memory
+                    ? undefined
+                    : await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {}),
                 skills: agent.skills &&
-                    (await Promise.all(agent.skills.map((filename) => loadAgent(join(dirname(path), filename))))),
+                    (await Promise.all(agent.skills.map((filename) => loadAgent(nodejs.path.join(nodejs.path.dirname(path), filename))))),
             });
         }
         if (agent.type === "mcp") {
@@ -54,7 +55,15 @@ export async function loadAgent(path) {
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-const { MODEL_PROVIDER, MODEL_NAME } = process.env;
+async function loadMemory(memories, provider, options) {
+    const M = !provider
+        ? memories[0]
+        : memories.find((i) => i.name.toLowerCase().includes(provider.toLowerCase()));
+    if (!M)
+        throw new Error(`Unsupported memory: ${provider}`);
+    return new M(options);
+}
+const { MODEL_PROVIDER, MODEL_NAME } = nodejs.env;
 const DEFAULT_MODEL_PROVIDER = "openai";
 export async function loadModel(models, model, modelOptions) {
     const params = {
@@ -92,17 +101,17 @@ const aigneFileSchema = z.object({
     skills: z.array(z.string()).nullish(),
 });
 export async function loadAIGNEFile(path) {
-    const raw = await tryOrThrow(() => readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
     const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
     const agent = tryOrThrow(() => aigneFileSchema.parse({ ...json, skills: json.skills ?? json.tools }), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
     return agent;
 }
 async function getAIGNEFilePath(path) {
-    const s = await stat(path);
+    const s = await nodejs.fs.stat(path);
     if (s.isDirectory()) {
         for (const file of AIGNE_FILE_NAME) {
-            const filePath = join(path, file);
-            if ((await stat(filePath)).isFile())
+            const filePath = nodejs.path.join(path, file);
+            if ((await nodejs.fs.stat(filePath)).isFile())
                 return filePath;
         }
     }

package/lib/esm/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, {
-    search?: string | undefined;
     limit?: number | undefined;
-}, {
     search?: string | undefined;
+}, {
     limit?: number | undefined;
+    search?: string | undefined;
 }>;
 /**
  * @hidden

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

@@ -1,9 +1,7 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type Message } from "../agents/agent.js";
+import { Agent, type AgentInvokeOptions, 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 { ChatMessagesTemplate } from "./template.js";
 export declare const MESSAGE_KEY = "$message";
 export declare function createMessage<V extends Message>(message: string, variables?: V): {
@@ -17,9 +15,7 @@ export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
-export interface PromptBuildOptions {
-    memory?: MemoryAgent | MemoryAgent[];
-    context: Context;
+export interface PromptBuildOptions extends AgentInvokeOptions {
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;

package/lib/esm/prompt/prompt-builder.js

@@ -1,9 +1,9 @@
-import { readFile } from "node:fs/promises";
 import { stringify } from "yaml";
 import { ZodObject } from "zod";
 import { Agent } from "../agents/agent.js";
 import { outputSchemaToResponseFormatSchema } from "../utils/json-schema.js";
-import { isNil, orArrayToArray, unique } from "../utils/type-utils.js";
+import { nodejs } from "../utils/nodejs.js";
+import { isNil, unique } from "../utils/type-utils.js";
 import { MEMORY_MESSAGE_TEMPLATE } from "./prompts/memory-message-template.js";
 import { AgentMessageTemplate, ChatMessagesTemplate, PromptTemplate, SystemMessageTemplate, UserMessageTemplate, } from "./template.js";
 export const MESSAGE_KEY = "$message";
@@ -31,7 +31,7 @@ export class PromptBuilder {
         throw new Error(`Invalid instructions ${instructions}`);
     }
     static async fromFile(path) {
-        const text = await readFile(path, "utf-8");
+        const text = await nodejs.fs.readFile(path, "utf-8");
         return PromptBuilder.from(text);
     }
     static fromMCPPromptResult(result) {
@@ -78,11 +78,15 @@ export class PromptBuilder {
         const messages = (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
-        for (const memory of orArrayToArray(options.memory ?? options.agent?.memories)) {
-            const memories = (await memory.retrieve({ search: input && getMessage(input) }, options.context))?.memories;
-            if (memories?.length)
-                messages.push(...this.convertMemoriesToMessages(memories, options));
+        const memories = [];
+        if (options.agent) {
+            memories.push(...(await options.agent.retrieveMemories({ search: options.input }, options)));
         }
+        if (options.memories?.length) {
+            memories.push(...options.memories);
+        }
+        if (memories.length)
+            messages.push(...this.convertMemoriesToMessages(memories, options));
         const content = input && getMessage(input);
         // add user input if it's not the same as the last message
         if (content && messages.at(-1)?.content !== content) {

package/lib/esm/prompt/template.js

@@ -1,7 +1,5 @@
-import { inspect } from "node:util";
 import Mustache from "mustache";
 import { z } from "zod";
-import { tryOrThrow } from "../utils/type-utils.js";
 export class PromptTemplate {
     template;
     static from(template) {
@@ -80,7 +78,7 @@ export class ToolMessageTemplate extends ChatMessageTemplate {
     constructor(content, toolCallId, name) {
         super("tool", typeof content === "string"
             ? content
-            : tryOrThrow(() => JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), `Failed to stringify tool content. toolCallId: ${toolCallId}, content: ${inspect(content)}`), name);
+            : JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), name);
         this.toolCallId = toolCallId;
     }
     format(variables) {

package/lib/esm/utils/logger.js

@@ -1,5 +1,5 @@
-import { isatty } from "node:tty";
 import debug from "debug";
+import { nodejs } from "./nodejs.js";
 export var LogLevel;
 (function (LogLevel) {
     LogLevel["ERROR"] = "error";
@@ -17,13 +17,13 @@ export class Logger {
         this.errorLogger = debug(`${options.ns}:error`);
         for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {
             // @ts-ignore
-            logger.useColors = isatty(process.stdout.fd);
+            logger.useColors = nodejs.isStdoutATTY;
             logger.enabled = true;
             logger.log = (...args) => this.logMessage(...args);
         }
         this.errorLogger.log = (...args) => this.logError(...args);
         // @ts-ignore
-        this.errorLogger.useColors = isatty(process.stderr.fd);
+        this.errorLogger.useColors = nodejs.isStderrATTY;
         this.errorLogger.enabled = true;
     }
     level;

package/lib/esm/utils/nodejs.d.ts

@@ -0,0 +1,8 @@
+export declare const nodejs: {
+    customInspect: any;
+    isStdoutATTY: boolean;
+    isStderrATTY: boolean;
+    env: NodeJS.ProcessEnv;
+    readonly fs: typeof import("node:fs/promises");
+    readonly path: typeof import("node:path");
+};