@aigne/core 1.13.0 → 1.14.0

package/lib/cjs/models/claude-chat-model.js

@@ -12,6 +12,9 @@ const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+/**
+ * @hidden
+ */
 exports.claudeChatModelOptionsSchema = zod_1.z.object({
     apiKey: zod_1.z.string().optional(),
     model: zod_1.z.string().optional(),
@@ -26,6 +29,24 @@ exports.claudeChatModelOptionsSchema = zod_1.z.object({
     })
         .optional(),
 });
+/**
+ * Implementation of the ChatModel interface for Anthropic's Claude API
+ *
+ * This model provides access to Claude's capabilities including:
+ * - Text generation
+ * - Tool use
+ * - JSON structured output
+ *
+ * Default model: 'claude-3-7-sonnet-latest'
+ *
+ * @example
+ * Here's how to create and use a Claude chat model:
+ * {@includeCode ../../test/models/claude-chat-model.test.ts#example-claude-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/claude-chat-model.test.ts#example-claude-chat-model-streaming-async-generator}
+ */
 class ClaudeChatModel extends chat_model_js_1.ChatModel {
     options;
     constructor(options) {
@@ -34,6 +55,9 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
         super();
         this.options = options;
     }
+    /**
+     * @hidden
+     */
     _client;
     get client() {
         const apiKey = this.options?.apiKey || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
@@ -45,7 +69,15 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input, _context, options) {
+    /**
+     * Process the input using Claude's chat model
+     * @param input - The input to process
+     * @returns The processed output from the model
+     */
+    process(input) {
+        return this._process(input);
+    }
+    async _process(input) {
         const model = this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
         const disableParallelToolUse = input.modelOptions?.parallelToolCalls === false ||
             this.modelOptions?.parallelToolCalls === false;
@@ -62,7 +94,7 @@ class ClaudeChatModel extends chat_model_js_1.ChatModel {
             ...body,
             stream: true,
         });
-        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+        if (input.responseFormat?.type !== "json_schema") {
             return this.extractResultFromClaudeStream(stream, true);
         }
         const result = await this.extractResultFromClaudeStream(stream);

package/lib/cjs/models/deepseek-chat-model.d.ts

@@ -1,4 +1,20 @@
 import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+/**
+ * Implementation of the ChatModel interface for DeepSeek's API
+ *
+ * This model uses OpenAI-compatible API format to interact with DeepSeek's models,
+ * but with specific configuration and capabilities for DeepSeek.
+ *
+ * Default model: 'deepseek-chat'
+ *
+ * @example
+ * Here's how to create and use a DeepSeek chat model:
+ * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model-streaming}
+ */
 export declare class DeepSeekChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;

package/lib/cjs/models/deepseek-chat-model.js

@@ -4,6 +4,22 @@ exports.DeepSeekChatModel = void 0;
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const DEEPSEEK_DEFAULT_CHAT_MODEL = "deepseek-chat";
 const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+/**
+ * Implementation of the ChatModel interface for DeepSeek's API
+ *
+ * This model uses OpenAI-compatible API format to interact with DeepSeek's models,
+ * but with specific configuration and capabilities for DeepSeek.
+ *
+ * Default model: 'deepseek-chat'
+ *
+ * @example
+ * Here's how to create and use a DeepSeek chat model:
+ * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/deepseek-chat-model.test.ts#example-deepseek-chat-model-streaming}
+ */
 class DeepSeekChatModel extends openai_chat_model_js_1.OpenAIChatModel {
     constructor(options) {
         super({

package/lib/cjs/models/gemini-chat-model.d.ts

@@ -1,4 +1,18 @@
 import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+/**
+ * Implementation of the ChatModel interface for Google's Gemini API
+ *
+ * This model uses OpenAI-compatible API format to interact with Google's Gemini models,
+ * providing access to models like Gemini 1.5 and Gemini 2.0.
+ *
+ * @example
+ * Here's how to create and use a Gemini chat model:
+ * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
+ */
 export declare class GeminiChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;

package/lib/cjs/models/gemini-chat-model.js

@@ -4,6 +4,20 @@ exports.GeminiChatModel = void 0;
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
 const GEMINI_DEFAULT_CHAT_MODEL = "gemini-2.0-flash";
+/**
+ * Implementation of the ChatModel interface for Google's Gemini API
+ *
+ * This model uses OpenAI-compatible API format to interact with Google's Gemini models,
+ * providing access to models like Gemini 1.5 and Gemini 2.0.
+ *
+ * @example
+ * Here's how to create and use a Gemini chat model:
+ * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/gemini-chat-model.test.ts#example-gemini-chat-model-streaming}
+ */
 class GeminiChatModel extends openai_chat_model_js_1.OpenAIChatModel {
     constructor(options) {
         super({

package/lib/cjs/models/ollama-chat-model.d.ts

@@ -1,4 +1,20 @@
 import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+/**
+ * Implementation of the ChatModel interface for Ollama
+ *
+ * This model allows you to run open-source LLMs locally using Ollama,
+ * with an OpenAI-compatible API interface.
+ *
+ * Default model: 'llama3.2'
+ *
+ * @example
+ * Here's how to create and use an Ollama chat model:
+ * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model-streaming}
+ */
 export declare class OllamaChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;

package/lib/cjs/models/ollama-chat-model.js

@@ -4,6 +4,22 @@ exports.OllamaChatModel = void 0;
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
 const OLLAMA_DEFAULT_CHAT_MODEL = "llama3.2";
+/**
+ * Implementation of the ChatModel interface for Ollama
+ *
+ * This model allows you to run open-source LLMs locally using Ollama,
+ * with an OpenAI-compatible API interface.
+ *
+ * Default model: 'llama3.2'
+ *
+ * @example
+ * Here's how to create and use an Ollama chat model:
+ * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/ollama-chat-model.test.ts#example-ollama-chat-model-streaming}
+ */
 class OllamaChatModel extends openai_chat_model_js_1.OpenAIChatModel {
     constructor(options) {
         super({

package/lib/cjs/models/open-router-chat-model.d.ts

@@ -1,4 +1,20 @@
 import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+/**
+ * Implementation of the ChatModel interface for OpenRouter service
+ *
+ * OpenRouter provides access to a variety of large language models through a unified API.
+ * This implementation uses the OpenAI-compatible interface to connect to OpenRouter's service.
+ *
+ * Default model: 'openai/gpt-4o'
+ *
+ * @example
+ * Here's how to create and use an OpenRouter chat model:
+ * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model-streaming}
+ */
 export declare class OpenRouterChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;

package/lib/cjs/models/open-router-chat-model.js

@@ -4,6 +4,22 @@ exports.OpenRouterChatModel = void 0;
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const OPEN_ROUTER_DEFAULT_CHAT_MODEL = "openai/gpt-4o";
 const OPEN_ROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+/**
+ * Implementation of the ChatModel interface for OpenRouter service
+ *
+ * OpenRouter provides access to a variety of large language models through a unified API.
+ * This implementation uses the OpenAI-compatible interface to connect to OpenRouter's service.
+ *
+ * Default model: 'openai/gpt-4o'
+ *
+ * @example
+ * Here's how to create and use an OpenRouter chat model:
+ * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/open-router-chat-model.test.ts#example-openrouter-chat-model-streaming}
+ */
 class OpenRouterChatModel extends openai_chat_model_js_1.OpenAIChatModel {
     constructor(options) {
         super({

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

@@ -1,8 +1,8 @@
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
 import { z } from "zod";
-import type { AgentInvokeOptions, AgentResponse } from "../agents/agent.js";
-import type { Context } from "../aigne/context.js";
+import type { AgentProcessResult } from "../agents/agent.js";
+import { type PromiseOrValue } from "../utils/type-utils.js";
 import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
 export interface OpenAIChatModelCapabilities {
     supportsNativeStructuredOutputs: boolean;
@@ -13,12 +13,36 @@ export interface OpenAIChatModelCapabilities {
     supportsToolStreaming: boolean;
     supportsTemperature: boolean;
 }
+/**
+ * Configuration options for OpenAI Chat Model
+ */
 export interface OpenAIChatModelOptions {
+    /**
+     * API key for OpenAI API
+     *
+     * If not provided, will look for OPENAI_API_KEY in environment variables
+     */
     apiKey?: string;
+    /**
+     * Base URL for OpenAI API
+     *
+     * Useful for proxies or alternate endpoints
+     */
     baseURL?: string;
+    /**
+     * OpenAI model to use
+     *
+     * Defaults to 'gpt-4o-mini'
+     */
     model?: string;
+    /**
+     * Additional model options to control behavior
+     */
     modelOptions?: ChatModelOptions;
 }
+/**
+ * @hidden
+ */
 export declare const openAIChatModelOptionsSchema: z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
     baseURL: z.ZodOptional<z.ZodString>;
@@ -70,9 +94,31 @@ export declare const openAIChatModelOptionsSchema: z.ZodObject<{
     apiKey?: string | undefined;
     baseURL?: string | undefined;
 }>;
+/**
+ * Implementation of the ChatModel interface for OpenAI's API
+ *
+ * This model provides access to OpenAI's capabilities including:
+ * - Text generation
+ * - Tool use with parallel tool calls
+ * - JSON structured output
+ * - Image understanding
+ *
+ * Default model: 'gpt-4o-mini'
+ *
+ * @example
+ * Here's how to create and use an OpenAI chat model:
+ * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model-streaming}
+ */
 export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
+    /**
+     * @hidden
+     */
     protected _client?: OpenAI;
     protected apiKeyEnvName: string;
     protected apiKeyDefault: string | undefined;
@@ -85,18 +131,36 @@ export declare class OpenAIChatModel extends ChatModel {
     protected supportsTemperature: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput, _context: Context, options?: AgentInvokeOptions): Promise<AgentResponse<ChatModelOutput>>;
+    /**
+     * Process the input and generate a response
+     * @param input The input to process
+     * @returns The generated response
+     */
+    process(input: ChatModelInput): PromiseOrValue<AgentProcessResult<ChatModelOutput>>;
+    private _process;
     private getParallelToolCalls;
     private getRunMessages;
     private getRunResponseFormat;
     private requestStructuredOutput;
     private extractResultFromStream;
 }
+/**
+ * @hidden
+ */
 export declare const ROLE_MAP: {
     [key in Role]: ChatCompletionMessageParam["role"];
 };
+/**
+ * @hidden
+ */
 export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+/**
+ * @hidden
+ */
 export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
     addTypeToEmptyParameters?: boolean;
 }): ChatCompletionTool[] | undefined;
+/**
+ * @hidden
+ */
 export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;

package/lib/cjs/models/openai-chat-model.js

@@ -21,6 +21,9 @@ const OPENAI_CHAT_MODEL_CAPABILITIES = {
     "o4-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
     "o3-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
 };
+/**
+ * @hidden
+ */
 exports.openAIChatModelOptionsSchema = zod_1.z.object({
     apiKey: zod_1.z.string().optional(),
     baseURL: zod_1.z.string().optional(),
@@ -36,6 +39,25 @@ exports.openAIChatModelOptionsSchema = zod_1.z.object({
     })
         .optional(),
 });
+/**
+ * Implementation of the ChatModel interface for OpenAI's API
+ *
+ * This model provides access to OpenAI's capabilities including:
+ * - Text generation
+ * - Tool use with parallel tool calls
+ * - JSON structured output
+ * - Image understanding
+ *
+ * Default model: 'gpt-4o-mini'
+ *
+ * @example
+ * Here's how to create and use an OpenAI chat model:
+ * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/openai-chat-model.test.ts#example-openai-chat-model-streaming}
+ */
 class OpenAIChatModel extends chat_model_js_1.ChatModel {
     options;
     constructor(options) {
@@ -46,6 +68,9 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
         const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : undefined;
         Object.assign(this, preset);
     }
+    /**
+     * @hidden
+     */
     _client;
     apiKeyEnvName = "OPENAI_API_KEY";
     apiKeyDefault;
@@ -69,7 +94,15 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input, _context, options) {
+    /**
+     * Process the input and generate a response
+     * @param input The input to process
+     * @returns The generated response
+     */
+    process(input) {
+        return this._process(input);
+    }
+    async _process(input) {
         const messages = await this.getRunMessages(input);
         const body = {
             model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
@@ -95,7 +128,7 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
             parallel_tool_calls: this.getParallelToolCalls(input),
             response_format: responseFormat,
         });
-        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+        if (input.responseFormat?.type !== "json_schema") {
             return await this.extractResultFromStream(stream, false, true);
         }
         const result = await this.extractResultFromStream(stream, jsonMode);
@@ -264,12 +297,18 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
     }
 }
 exports.OpenAIChatModel = OpenAIChatModel;
+/**
+ * @hidden
+ */
 exports.ROLE_MAP = {
     system: "system",
     user: "user",
     agent: "assistant",
     tool: "tool",
 };
+/**
+ * @hidden
+ */
 async function contentsFromInputMessages(messages) {
     return messages.map((i) => ({
         role: exports.ROLE_MAP[i.role],
@@ -299,6 +338,9 @@ async function contentsFromInputMessages(messages) {
         name: i.name,
     }));
 }
+/**
+ * @hidden
+ */
 function toolsFromInputTools(tools, options) {
     return tools?.length
         ? tools.map((i) => {
@@ -317,6 +359,9 @@ function toolsFromInputTools(tools, options) {
         })
         : undefined;
 }
+/**
+ * @hidden
+ */
 function jsonSchemaToOpenAIJsonSchema(schema) {
     if (schema?.type === "object") {
         const { required, properties } = schema;

package/lib/cjs/models/xai-chat-model.d.ts

@@ -1,4 +1,20 @@
 import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+/**
+ * Implementation of the ChatModel interface for X.AI's API (Grok)
+ *
+ * This model uses OpenAI-compatible API format to interact with X.AI models,
+ * providing access to models like Grok.
+ *
+ * Default model: 'grok-2-latest'
+ *
+ * @example
+ * Here's how to create and use an X.AI chat model:
+ * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model-streaming}
+ */
 export declare class XAIChatModel extends OpenAIChatModel {
     constructor(options?: OpenAIChatModelOptions);
     protected apiKeyEnvName: string;

package/lib/cjs/models/xai-chat-model.js

@@ -4,6 +4,22 @@ exports.XAIChatModel = void 0;
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
+/**
+ * Implementation of the ChatModel interface for X.AI's API (Grok)
+ *
+ * This model uses OpenAI-compatible API format to interact with X.AI models,
+ * providing access to models like Grok.
+ *
+ * Default model: 'grok-2-latest'
+ *
+ * @example
+ * Here's how to create and use an X.AI chat model:
+ * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model}
+ *
+ * @example
+ * Here's an example with streaming response:
+ * {@includeCode ../../test/models/xai-chat-model.test.ts#example-xai-chat-model-streaming}
+ */
 class XAIChatModel extends openai_chat_model_js_1.OpenAIChatModel {
     constructor(options) {
         super({

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

@@ -1,20 +1,19 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
-import type { AgentMemory } from "../agents/memory.js";
 import type { Context } from "../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 const DEFAULT_MAX_HISTORY_MESSAGES = 10;
 export declare function createMessage<I extends Message>(message: string | I): I;
 export declare function getMessage(input: Message): string | undefined;
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
-    memory?: AgentMemory;
-    context?: Context;
+    memory?: MemoryAgent | MemoryAgent[];
+    context: Context;
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
@@ -37,6 +36,7 @@ export declare class PromptBuilder {
         toolAgents?: Agent[];
     }>;
     private buildMessages;
+    private convertMemoriesToMessages;
     private buildResponseFormat;
     private buildTools;
 }

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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptBuilder = exports.DEFAULT_MAX_HISTORY_MESSAGES = exports.MESSAGE_KEY = void 0;
+exports.PromptBuilder = exports.MESSAGE_KEY = void 0;
 exports.createMessage = createMessage;
 exports.getMessage = getMessage;
 const promises_1 = require("node:fs/promises");
+const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
+const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const template_js_1 = require("./template.js");
 exports.MESSAGE_KEY = "$message";
-exports.DEFAULT_MAX_HISTORY_MESSAGES = 10;
 function createMessage(message) {
     return typeof message === "string"
         ? { [exports.MESSAGE_KEY]: message }
@@ -72,26 +73,20 @@ class PromptBuilder {
     instructions;
     async build(options) {
         return {
-            messages: this.buildMessages(options),
+            messages: await this.buildMessages(options),
             responseFormat: this.buildResponseFormat(options),
             ...this.buildTools(options),
         };
     }
-    buildMessages(options) {
+    async buildMessages(options) {
         const { input } = options;
         const messages = (typeof this.instructions === "string"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(options.input) ?? [];
-        const memory = options.memory ?? options.agent?.memory;
-        if (memory?.enabled) {
-            const k = memory.maxMemoriesInChat ?? exports.DEFAULT_MAX_HISTORY_MESSAGES;
-            const histories = memory.memories.slice(-k);
-            if (histories?.length)
-                messages.push(...histories.map((i) => ({
-                    role: i.role,
-                    content: convertMessageToContent(i.content),
-                    name: i.source,
-                })));
+        for (const memory of (0, type_utils_js_1.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 content = input && getMessage(input);
         // add user input if it's not the same as the last message
@@ -100,6 +95,15 @@ class PromptBuilder {
         }
         return messages;
     }
+    convertMemoriesToMessages(memories, options) {
+        const str = (0, yaml_1.stringify)(memories.map((i) => i.content));
+        return [
+            {
+                role: "system",
+                content: template_js_1.PromptTemplate.from(options.agent?.memoryPromptTemplate || memory_message_template_js_1.MEMORY_MESSAGE_TEMPLATE).format({ memories: str }),
+            },
+        ];
+    }
     buildResponseFormat(options) {
         const outputSchema = options.outputSchema || options.agent?.outputSchema;
         if (!outputSchema)
@@ -119,6 +123,7 @@ class PromptBuilder {
     buildTools(options) {
         const toolAgents = (0, type_utils_js_1.unique)((options.context?.skills ?? [])
             .concat(options.agent?.skills ?? [])
+            .concat(options.agent?.memoryAgentsAsTools ? options.agent.memories : [])
             // TODO: support nested tools?
             .flatMap((i) => (i.isInvokable ? i.skills.concat(i) : i.skills)), (i) => i.name);
         const tools = toolAgents.map((i) => ({
@@ -175,7 +180,3 @@ function isFromPath(value) {
 function isEmptyObjectType(schema) {
     return schema instanceof zod_1.ZodObject && Object.keys(schema.shape).length === 0;
 }
-function convertMessageToContent(i) {
-    const str = i[exports.MESSAGE_KEY];
-    return !(0, type_utils_js_1.isNil)(str) ? (typeof str === "string" ? str : JSON.stringify(str)) : JSON.stringify(i);
-}

package/lib/cjs/prompt/prompts/memory-message-template.d.ts

@@ -0,0 +1 @@
+export declare const MEMORY_MESSAGE_TEMPLATE = "Here are some useful memories to consider:\n\n<memories>\n{{memories}}\n</memories>\n";

package/lib/cjs/prompt/prompts/memory-message-template.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_MESSAGE_TEMPLATE = void 0;
+exports.MEMORY_MESSAGE_TEMPLATE = `\
+Here are some useful memories to consider:
+
+<memories>
+{{memories}}
+</memories>
+`;

package/lib/cjs/prompt/template.js

@@ -5,8 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatMessagesTemplate = exports.ToolMessageTemplate = exports.AgentMessageTemplate = exports.UserMessageTemplate = exports.SystemMessageTemplate = exports.ChatMessageTemplate = exports.PromptTemplate = void 0;
 exports.parseChatMessages = parseChatMessages;
+const node_util_1 = require("node:util");
 const mustache_1 = __importDefault(require("mustache"));
 const zod_1 = require("zod");
+const type_utils_js_1 = require("../utils/type-utils.js");
 class PromptTemplate {
     template;
     static from(template) {
@@ -88,7 +90,9 @@ class ToolMessageTemplate extends ChatMessageTemplate {
         return new ToolMessageTemplate(content, toolCallId, name);
     }
     constructor(content, toolCallId, name) {
-        super("tool", typeof content === "string" ? content : JSON.stringify(content), name);
+        super("tool", typeof content === "string"
+            ? content
+            : (0, type_utils_js_1.tryOrThrow)(() => JSON.stringify(content), `Failed to stringify tool content. toolCallId: ${toolCallId}, content: ${(0, node_util_1.inspect)(content)}`), name);
         this.toolCallId = toolCallId;
     }
     format(variables) {