@aigne/core 1.1.0-beta.4 → 1.1.0-beta.6

package/lib/cjs/utils/run-chat-loop.js

@@ -6,15 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runChatLoopInTerminal = runChatLoopInTerminal;
 const inquirer_1 = __importDefault(require("inquirer"));
 const logger_1 = require("./logger");
-async function runChatLoopInTerminal(userAgent, options) {
+async function runChatLoopInTerminal(userAgent, { log = console.log.bind(console), ...options } = {}) {
     if (options?.welcome)
-        console.log(options.welcome);
+        log(options.welcome);
+    if (options?.initialCall) {
+        await callAgent(userAgent, options.initialCall, { ...options, log });
+    }
     for (let i = 0;; i++) {
         const { question } = await inquirer_1.default.prompt([
             {
                 type: "input",
                 name: "question",
-                message: ">",
+                message: "💬",
                 default: i === 0 ? options?.defaultQuestion : undefined,
             },
         ]);
@@ -22,23 +25,30 @@ async function runChatLoopInTerminal(userAgent, options) {
             continue;
         const cmd = COMMANDS[question.trim()];
         if (cmd) {
-            await cmd();
+            const result = cmd();
+            if (result.message)
+                log(result.message);
+            if (result?.exit)
+                break;
             continue;
         }
-        const response = await logger_1.logger.spinner(userAgent.call(question));
-        if (options?.onResponse)
-            options.onResponse(response);
-        else
-            console.log(response);
+        await callAgent(userAgent, question, { ...options, log });
     }
 }
+async function callAgent(agent, input, options) {
+    const response = await logger_1.logger.spinner(agent.call(input), "🤖");
+    if (options?.onResponse)
+        options.onResponse(response);
+    else
+        options.log(response);
+}
 const COMMANDS = {
-    "/exit": () => process.exit(0),
-    "/help": () => {
-        console.log(`\
+    "/exit": () => ({ exit: true }),
+    "/help": () => ({
+        message: `\
 Commands:
   /exit - exit the chat loop
   /help - show this help message
-`);
-    },
+`,
+    }),
 };

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

@@ -3,3 +3,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "number"): number | undefined;
+export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
+    [key: string]: T;
+};

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNonNullable = isNonNullable;
 exports.orArrayToArray = orArrayToArray;
 exports.get = get;
+exports.createAccessorArray = createAccessorArray;
 const lodash_1 = require("lodash");
 const isNil_1 = __importDefault(require("lodash/isNil"));
 function isNonNullable(value) {
@@ -23,3 +24,8 @@ function get(obj, path, type) {
     if (type === "number" && typeof v === "number")
         return v;
 }
+function createAccessorArray(array, accessor) {
+    return new Proxy(array, {
+        get: (t, p, r) => Reflect.get(t, p, r) ?? accessor(array, p),
+    });
+}

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

@@ -7,6 +7,8 @@ export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends Age
     instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
 export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
@@ -16,5 +18,7 @@ export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentO
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages: number;
     process(input: I, context?: Context): Promise<O>;
 }

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

@@ -1,8 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { CallToolResult, GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
+    prompts?: MCPPrompt[];
 }
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
@@ -14,14 +16,24 @@ export declare class MCPAgent extends Agent {
     private static fromTransport;
     constructor(options: MCPAgentOptions);
     private client;
+    readonly prompts: MCPPrompt[] & {
+        [key: string]: MCPPrompt;
+    };
     shutdown(): Promise<void>;
 }
-export interface MCPToolOptions extends AgentOptions {
+export interface MCPToolBaseOptions<I extends AgentInput, O extends AgentOutput> extends AgentOptions<I, O> {
     client: Client;
 }
-export declare class MCPTool extends Agent {
-    constructor(options: MCPToolOptions);
-    private client;
-    private get mcpServer();
-    process(input: AgentInput): Promise<AgentOutput>;
+export declare abstract class MCPBase<I extends AgentInput, O extends AgentOutput> extends Agent<I, O> {
+    constructor(options: MCPToolBaseOptions<I, O>);
+    protected client: Client;
+    protected get mcpServer(): string | undefined;
+}
+export declare class MCPTool extends MCPBase<AgentInput, CallToolResult> {
+    process(input: AgentInput): Promise<CallToolResult>;
+}
+export declare class MCPPrompt extends MCPBase<{
+    [key: string]: string;
+}, GetPromptResult> {
+    process(input: AgentInput): Promise<GetPromptResult>;
 }

package/lib/dts/index.d.ts

@@ -8,4 +8,5 @@ export * from "./models/chat";
 export * from "./models/chat-openai";
 export * from "./prompt/prompt-builder";
 export * from "./prompt/template";
+export * from "./utils/logger";
 export * from "./utils/run-chat-loop";

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

@@ -1,14 +1,18 @@
+import type { GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput } from "../agents/agent";
 import type { AIAgent } from "../agents/ai-agent";
 import type { Context } from "../execution-engine/context";
 import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
+import { ChatMessagesTemplate } from "./template";
 export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
 export declare function userInput(message: string | object): AgentInput;
 export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
 export interface PromptBuilderOptions {
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
     context?: Context;
     agent?: AIAgent;
     input?: AgentInput;
@@ -16,15 +20,19 @@ export interface PromptBuilderBuildOptions {
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;
+    static from(instructions: GetPromptResult): PromptBuilder;
     static from(instructions: {
         path: string;
     }): Promise<PromptBuilder>;
     static from(instructions: string | {
         path: string;
-    }): PromptBuilder | Promise<PromptBuilder>;
+    } | GetPromptResult): PromptBuilder | Promise<PromptBuilder>;
     private static fromFile;
+    private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
+    histories: ChatModelInputMessage[];
+    addHistory(...messages: ChatModelInputMessage[]): void;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;

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

@@ -1,4 +1,4 @@
-import { type Debugger } from "debug";
+import debug, { type Debugger } from "debug";
 interface DebugWithSpinner extends Debugger {
     spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void, options?: {
         disabled?: boolean;
@@ -6,7 +6,11 @@ interface DebugWithSpinner extends Debugger {
     extend: (namespace: string) => DebugWithSpinner;
 }
 declare function spinner<T>(promise: Promise<T>, message?: string, callback?: (result: T) => void): Promise<T>;
-export declare const logger: {
+export declare const logger: debug.Debug & {
+    debug: debug.Debug;
+    default: debug.Debug;
+} & {
+    globalSpinner: import("ora").Ora;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;

package/lib/dts/utils/mcp-utils.d.ts

@@ -0,0 +1,5 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { ListPromptsResult, ListToolsResult } from "@modelcontextprotocol/sdk/types";
+import { MCPPrompt, MCPTool } from "../agents/mcp-agent";
+export declare function toolFromMCPTool(client: Client, tool: ListToolsResult["tools"][number]): MCPTool;
+export declare function promptFromMCPPrompt(client: Client, prompt: ListPromptsResult["prompts"][number]): MCPPrompt;

package/lib/dts/utils/run-chat-loop.d.ts

@@ -1,8 +1,10 @@
-import type { AgentOutput } from "../agents/agent";
+import type { AgentInput, AgentOutput } from "../agents/agent";
 import type { UserAgent } from "../execution-engine";
 export interface ChatLoopOptions {
+    log?: typeof console.log;
+    initialCall?: AgentInput | string;
     welcome?: string;
     defaultQuestion?: string;
     onResponse?: (response: AgentOutput) => void;
 }
-export declare function runChatLoopInTerminal(userAgent: UserAgent, options?: ChatLoopOptions): Promise<void>;
+export declare function runChatLoopInTerminal(userAgent: UserAgent, { log, ...options }?: ChatLoopOptions): Promise<void>;

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

@@ -3,3 +3,6 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function get(obj: unknown, path: string | string[], type?: undefined): unknown | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "string"): string | undefined;
 export declare function get(obj: unknown, path: string | string[], type: "number"): number | undefined;
+export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
+    [key: string]: T;
+};

package/lib/esm/agents/agent.js

@@ -2,6 +2,7 @@ import EventEmitter from "node:events";
 import { z } from "zod";
 import { userInput } from "../prompt/prompt-builder";
 import { logger } from "../utils/logger";
+import { createAccessorArray } from "../utils/type-utils";
 import { transferToAgentOutput } from "./types";
 export class Agent extends EventEmitter {
     static from(options) {
@@ -29,9 +30,7 @@ export class Agent extends EventEmitter {
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
-    tools = new Proxy([], {
-        get: (t, p, r) => Reflect.get(t, p, r) ?? t.find((t) => t.name === p),
-    });
+    tools = createAccessorArray([], (arr, name) => arr.find((t) => t.name === name));
     disableLogging;
     addTool(tool) {
         this.tools.push(typeof tool === "function" ? functionToAgent(tool) : tool);
@@ -48,7 +47,7 @@ export class Agent extends EventEmitter {
             const parsedOutput = this.outputSchema.passthrough().parse(output);
             return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
         });
-        return logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger.debug("%O", { input, output }), { disabled: this.disableLogging });
+        return logger.debug.spinner(result, `Call agent ${this.name}`, (output) => logger.debug("input: %O\noutput: %O", input, output), { disabled: this.disableLogging });
     }
     async shutdown() { }
 }

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

@@ -7,6 +7,8 @@ export interface AIAgentOptions<I extends AgentInput = AgentInput, O extends Age
     instructions?: string | PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
 export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentOutput = AgentOutput> extends Agent<I, O> {
@@ -16,5 +18,7 @@ export declare class AIAgent<I extends AgentInput = AgentInput, O extends AgentO
     instructions: PromptBuilder;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
+    enableHistory?: boolean;
+    maxHistoryMessages: number;
     process(input: I, context?: Context): Promise<O>;
 }

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

@@ -3,6 +3,7 @@ import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template";
 import { Agent } from "./agent";
 import { isTransferAgentOutput, transferAgentOutputKey } from "./types";
 const DEFAULT_OUTPUT_KEY = "text";
+const DEFAULT_MAX_HISTORY_MESSAGES = 10;
 export class AIAgent extends Agent {
     static from(options) {
         return new AIAgent(options);
@@ -16,27 +17,35 @@ export class AIAgent extends Agent {
                 : (options.instructions ?? new PromptBuilder());
         this.outputKey = options.outputKey;
         this.toolChoice = options.toolChoice;
+        this.enableHistory = options.enableHistory;
+        this.maxHistoryMessages = options.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
     }
     model;
     instructions;
     outputKey;
     toolChoice;
+    enableHistory;
+    maxHistoryMessages;
     async process(input, context) {
         const model = context?.model ?? this.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
         let transferOutput;
-        const { toolAgents, ...modelInput } = await this.instructions.build({
+        const { toolAgents, messages, ...modelInput } = await this.instructions.build({
+            enableHistory: this.enableHistory,
+            maxHistoryMessages: this.maxHistoryMessages,
             agent: this,
             input,
             model,
             context,
         });
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
+        const toolCallMessages = [];
         for (;;) {
-            const { text, json, toolCalls } = await model.call(modelInput, context);
+            const { text, json, toolCalls } = await model.call({ ...modelInput, messages: messages.concat(toolCallMessages) }, context);
             if (toolCalls?.length) {
                 const executedToolCalls = [];
+                // Execute tools
                 for (const call of toolCalls) {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
@@ -50,21 +59,27 @@ export class AIAgent extends Agent {
                         executedToolCalls.push({ call, output });
                     }
                 }
-                if (this.toolChoice === "router") {
-                    const output = executedToolCalls[0]?.output;
-                    if (!output || executedToolCalls.length !== 1) {
-                        throw new Error("Router toolChoice requires exactly one tool to be executed");
-                    }
-                    return output;
-                }
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    modelInput.messages.push(AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format());
-                    modelInput.messages.push(...executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()));
+                    toolCallMessages.push(AgentMessageTemplate.from(executedToolCalls.map(({ call }) => call)).format(), ...executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()));
+                    // Return the output of the first tool if the toolChoice is "router"
+                    if (this.toolChoice === "router") {
+                        const output = executedToolCalls[0]?.output;
+                        if (!output || executedToolCalls.length !== 1) {
+                            throw new Error("Router toolChoice requires exactly one tool to be executed");
+                        }
+                        return output;
+                    }
                     continue;
                 }
             }
             const result = {};
+            if (json) {
+                this.instructions.addHistory(AgentMessageTemplate.from(JSON.stringify(json)).format());
+            }
+            else if (text) {
+                this.instructions.addHistory(AgentMessageTemplate.from(text).format());
+            }
             if (modelInput.responseFormat?.type === "json_schema") {
                 Object.assign(result, json);
             }

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

@@ -1,8 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { CallToolResult, GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput, type AgentOptions, type AgentOutput } from "./agent";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
+    prompts?: MCPPrompt[];
 }
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
@@ -14,14 +16,24 @@ export declare class MCPAgent extends Agent {
     private static fromTransport;
     constructor(options: MCPAgentOptions);
     private client;
+    readonly prompts: MCPPrompt[] & {
+        [key: string]: MCPPrompt;
+    };
     shutdown(): Promise<void>;
 }
-export interface MCPToolOptions extends AgentOptions {
+export interface MCPToolBaseOptions<I extends AgentInput, O extends AgentOutput> extends AgentOptions<I, O> {
     client: Client;
 }
-export declare class MCPTool extends Agent {
-    constructor(options: MCPToolOptions);
-    private client;
-    private get mcpServer();
-    process(input: AgentInput): Promise<AgentOutput>;
+export declare abstract class MCPBase<I extends AgentInput, O extends AgentOutput> extends Agent<I, O> {
+    constructor(options: MCPToolBaseOptions<I, O>);
+    protected client: Client;
+    protected get mcpServer(): string | undefined;
+}
+export declare class MCPTool extends MCPBase<AgentInput, CallToolResult> {
+    process(input: AgentInput): Promise<CallToolResult>;
+}
+export declare class MCPPrompt extends MCPBase<{
+    [key: string]: string;
+}, GetPromptResult> {
+    process(input: AgentInput): Promise<GetPromptResult>;
 }

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

@@ -1,9 +1,9 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { jsonSchemaToZod } from "@n8n/json-schema-to-zod";
-import { z } from "zod";
 import { logger } from "../utils/logger";
+import { promptFromMCPPrompt, toolFromMCPTool } from "../utils/mcp-utils";
+import { createAccessorArray } from "../utils/type-utils";
 import { Agent } from "./agent";
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
@@ -21,7 +21,7 @@ export class MCPAgent extends Agent {
             return MCPAgent.fromTransport(transport);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new StdioClientTransport(options);
+            const transport = new StdioClientTransport({ ...options, stderr: "pipe" });
             return MCPAgent.fromTransport(transport);
         }
         return new MCPAgent(options);
@@ -33,35 +33,33 @@ export class MCPAgent extends Agent {
         });
         await debug.spinner(client.connect(transport), "Connecting to MCP server");
         const mcpServer = getMCPServerName(client);
-        const { tools: mcpTools } = await debug.spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools));
-        const tools = mcpTools.map((tool) => {
-            return new MCPTool({
-                client,
-                name: tool.name,
-                description: tool.description,
-                inputSchema: jsonSchemaToZod(tool.inputSchema),
-                outputSchema: z
-                    .object({
-                    _meta: z.record(z.unknown()).optional(),
-                    content: z.array(z.record(z.unknown())),
-                    isError: z.boolean().optional(),
-                })
-                    .passthrough(),
-            });
-        });
-        return new MCPAgent({ client, tools });
+        const { tools: isToolsAvailable, prompts: isPromptsAvailable } = client.getServerCapabilities() ?? {};
+        const tools = isToolsAvailable
+            ? await debug
+                .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
+                .then(({ tools }) => tools.map((tool) => toolFromMCPTool(client, tool)))
+            : undefined;
+        const prompts = isPromptsAvailable
+            ? await debug
+                .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
+                .then(({ prompts }) => prompts.map((prompt) => promptFromMCPPrompt(client, prompt)))
+            : undefined;
+        return new MCPAgent({ client, tools, prompts });
     }
     constructor(options) {
         super(options);
         this.client = options.client;
+        if (options.prompts?.length)
+            this.prompts.push(...options.prompts);
     }
     client;
+    prompts = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     async shutdown() {
         super.shutdown();
         await this.client.close();
     }
 }
-export class MCPTool extends Agent {
+export class MCPBase extends Agent {
     constructor(options) {
         super(options);
         this.client = options.client;
@@ -70,8 +68,16 @@ export class MCPTool extends Agent {
     get mcpServer() {
         return getMCPServerName(this.client);
     }
+}
+export class MCPTool extends MCPBase {
+    async process(input) {
+        const result = await debug.spinner(this.client.callTool({ name: this.name, arguments: input }), `Call tool ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
+        return result;
+    }
+}
+export class MCPPrompt extends MCPBase {
     async process(input) {
-        const result = await debug.spinner(this.client.callTool({ name: this.name, arguments: input }), `Call tool ${this.name} from ${this.mcpServer}`, (output) => debug("%O", { input, output }));
+        const result = await debug.spinner(this.client.getPrompt({ name: this.name, arguments: input }), `Get prompt ${this.name} from ${this.mcpServer}`, (output) => debug("input: %O\noutput: %O", input, output));
         return result;
     }
 }

package/lib/esm/index.d.ts

@@ -8,4 +8,5 @@ export * from "./models/chat";
 export * from "./models/chat-openai";
 export * from "./prompt/prompt-builder";
 export * from "./prompt/template";
+export * from "./utils/logger";
 export * from "./utils/run-chat-loop";

package/lib/esm/index.js

@@ -8,4 +8,5 @@ export * from "./models/chat";
 export * from "./models/chat-openai";
 export * from "./prompt/prompt-builder";
 export * from "./prompt/template";
+export * from "./utils/logger";
 export * from "./utils/run-chat-loop";

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

@@ -1,14 +1,18 @@
+import type { GetPromptResult } from "@modelcontextprotocol/sdk/types";
 import { Agent, type AgentInput } from "../agents/agent";
 import type { AIAgent } from "../agents/ai-agent";
 import type { Context } from "../execution-engine/context";
 import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../models/chat";
+import { ChatMessagesTemplate } from "./template";
 export declare const USER_INPUT_MESSAGE_KEY = "$user_input_message";
 export declare function userInput(message: string | object): AgentInput;
 export declare function addMessagesToInput(input: AgentInput, messages: ChatModelInputMessage[]): AgentInput;
 export interface PromptBuilderOptions {
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
 }
 export interface PromptBuilderBuildOptions {
+    enableHistory?: boolean;
+    maxHistoryMessages?: number;
     context?: Context;
     agent?: AIAgent;
     input?: AgentInput;
@@ -16,15 +20,19 @@ export interface PromptBuilderBuildOptions {
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;
+    static from(instructions: GetPromptResult): PromptBuilder;
     static from(instructions: {
         path: string;
     }): Promise<PromptBuilder>;
     static from(instructions: string | {
         path: string;
-    }): PromptBuilder | Promise<PromptBuilder>;
+    } | GetPromptResult): PromptBuilder | Promise<PromptBuilder>;
     private static fromFile;
+    private static fromMCPPromptResult;
     constructor(options?: PromptBuilderOptions);
-    instructions?: string;
+    instructions?: string | ChatMessagesTemplate;
+    histories: ChatModelInputMessage[];
+    addHistory(...messages: ChatModelInputMessage[]): void;
     build(options: PromptBuilderBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;