@aigne/core 1.72.0-beta.6 → 1.72.0-beta.8

package/lib/esm/agents/agent.js

@@ -104,7 +104,6 @@ export class Agent {
         if (options.skills?.length)
             this.skills.push(...options.skills.map(functionToAgent));
         this.disableEvents = options.disableEvents;
-        this.historyConfig = options.historyConfig;
         if (Array.isArray(options.memory)) {
             this.memories.push(...options.memory);
         }
@@ -131,15 +130,15 @@ export class Agent {
                     : options.retryOnError;
         this.guideRails = options.guideRails;
     }
+    afs;
+    tag;
     /**
      * List of memories this agent can use
      *
      * @deprecated use afs instead
      */
     memories = [];
-    afs;
     asyncMemoryRecord;
-    tag;
     /**
      * Maximum number of memory items to retrieve
      */
@@ -284,7 +283,6 @@ export class Agent {
      * agentSucceed, or agentFailed
      */
     disableEvents;
-    historyConfig;
     subscriptions = [];
     /**
      * Attach agent to context:
@@ -415,11 +413,15 @@ export class Agent {
                     : isAsyncGenerator(response)
                         ? asyncGeneratorToReadableStream(response)
                         : objectToAgentResponseStream(response);
+                const messages = [];
                 for await (const chunk of stream) {
                     mergeAgentResponseChunk(output, chunk);
                     yield chunk;
+                    if (isAgentResponseProgress(chunk) && chunk.progress.event === "message") {
+                        messages.push(chunk.progress.message);
+                    }
                 }
-                let result = await this.processAgentOutput(input, output, options);
+                let result = await this.processAgentOutput(input, output, { ...options, messages });
                 if (attempt > 0) {
                     result = { ...result, $meta: { ...result.$meta, retries: attempt } };
                 }
@@ -516,7 +518,7 @@ export class Agent {
      * @param options Invocation options
      * @returns Final processed output
      */
-    async processAgentOutput(input, output, options) {
+    async processAgentOutput(input, output, { messages, ...options }) {
         const { context } = options;
         if (!isRecord(output)) {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
@@ -528,8 +530,14 @@ export class Agent {
         const o = await this.callHooks(["onSuccess", "onEnd"], { input, output: finalOutput }, options);
         if (o?.output)
             finalOutput = o.output;
-        if (this.historyConfig?.disabled !== true)
-            this.afs?.emit("agentSucceed", { input, output: finalOutput });
+        this.afs?.emit("agentSucceed", {
+            agentId: this.name,
+            userId: context.userContext.userId,
+            sessionId: context.userContext.sessionId,
+            input,
+            output: finalOutput,
+            messages,
+        });
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
         return finalOutput;

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

@@ -1,4 +1,8 @@
 import { type ZodObject, type ZodType, z } from "zod";
+import { type NestAgentSchema } from "../loader/agent-yaml.js";
+import type { AgentLoadOptions } from "../loader/index.js";
+import { type Instructions } from "../loader/schema.js";
+import type { CompactConfig } from "../prompt/agent-session.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentInvokeOptions, type AgentOptions, type AgentProcessAsyncGenerator, type AgentProcessResult, type Message } from "./agent.js";
 import type { ChatModel, ChatModelInput } from "./chat-model.js";
@@ -23,8 +27,6 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      * more complex prompt templates
      */
     instructions?: string | PromptBuilder;
-    autoReorderSystemMessages?: boolean;
-    autoMergeSystemMessages?: boolean;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -124,6 +126,20 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      */
     memoryPromptTemplate?: string;
     useMemoriesFromContext?: boolean;
+    compact?: CompactConfig;
+}
+export interface AIAgentLoadSchema {
+    instructions?: Instructions;
+    inputKey?: string;
+    inputFileKey?: string;
+    outputKey?: string;
+    outputFileKey?: string;
+    toolChoice?: AIAgentToolChoice;
+    toolCallsConcurrency?: number;
+    keepTextInToolUses?: boolean;
+    compact?: Omit<CompactConfig, "compactor"> & {
+        compactor?: NestAgentSchema;
+    };
 }
 /**
  * Tool choice options for AI agents
@@ -194,6 +210,7 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
     static load<I extends Message = any, O extends Message = any>(options: {
         filepath: string;
         parsed: object;
+        options?: AgentLoadOptions;
     }): Promise<Agent<I, O>>;
     /**
      * Create an AIAgent with the specified options
@@ -225,8 +242,6 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-prompt-builder}
      */
     instructions: PromptBuilder;
-    autoReorderSystemMessages?: boolean;
-    autoMergeSystemMessages?: boolean;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -322,6 +337,7 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
         metadataEnd: string;
         parse: (raw: string) => object;
     };
+    compact?: CompactConfig;
     get inputSchema(): ZodType<I>;
     /**
      * Process an input message and generate a response

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
+import { getNestAgentSchema } from "../loader/agent-yaml.js";
 import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize, } from "../loader/schema.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
-import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
 import * as fastq from "../utils/queue.js";
 import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
@@ -88,10 +88,9 @@ export class AIAgent extends Agent {
     tag = "AIAgent";
     static schema({ filepath }) {
         const instructionsSchema = getInstructionsSchema({ filepath });
+        const nestAgentSchema = getNestAgentSchema({ filepath });
         return camelizeSchema(z.object({
             instructions: optionalize(instructionsSchema),
-            autoReorderSystemMessages: optionalize(z.boolean()),
-            autoMergeSystemMessages: optionalize(z.boolean()),
             inputKey: optionalize(z.string()),
             outputKey: optionalize(z.string()),
             inputFileKey: optionalize(z.string()),
@@ -101,6 +100,13 @@ export class AIAgent extends Agent {
             keepTextInToolUses: optionalize(z.boolean()),
             catchToolsError: optionalize(z.boolean()),
             structuredStreamMode: optionalize(z.boolean()),
+            compact: camelizeSchema(optionalize(z.object({
+                mode: optionalize(z.enum(["auto", "disabled"])),
+                maxTokens: z.number().int().min(0).optional(),
+                keepRecentRatio: optionalize(z.number().min(0).max(1)),
+                async: optionalize(z.boolean()),
+                compactor: optionalize(nestAgentSchema),
+            }))),
         }));
     }
     static async load(options) {
@@ -110,6 +116,12 @@ export class AIAgent extends Agent {
             ...options.parsed,
             ...valid,
             instructions: valid.instructions && instructionsToPromptBuilder(valid.instructions),
+            compact: {
+                ...valid.compact,
+                compactor: valid.compact?.compactor
+                    ? await options.options?.loadNestAgent(options.filepath, valid.compact.compactor, options.options)
+                    : undefined,
+            },
         });
     }
     /**
@@ -139,8 +151,6 @@ export class AIAgent extends Agent {
             typeof options.instructions === "string"
                 ? PromptBuilder.from(options.instructions)
                 : (options.instructions ?? new PromptBuilder());
-        this.autoReorderSystemMessages = options.autoReorderSystemMessages ?? true;
-        this.autoMergeSystemMessages = options.autoMergeSystemMessages ?? true;
         this.inputKey = options.inputKey;
         this.inputFileKey = options.inputFileKey;
         this.outputKey = options.outputKey || DEFAULT_OUTPUT_KEY;
@@ -152,6 +162,7 @@ export class AIAgent extends Agent {
         this.memoryAgentsAsTools = options.memoryAgentsAsTools;
         this.memoryPromptTemplate = options.memoryPromptTemplate;
         this.useMemoriesFromContext = options.useMemoriesFromContext;
+        this.compact = options.compact;
         if (typeof options.catchToolsError === "boolean")
             this.catchToolsError = options.catchToolsError;
         this.structuredStreamMode = options.structuredStreamMode;
@@ -177,8 +188,6 @@ export class AIAgent extends Agent {
      * {@includeCode ../../test/agents/ai-agent.test.ts#example-ai-agent-prompt-builder}
      */
     instructions;
-    autoReorderSystemMessages;
-    autoMergeSystemMessages;
     /**
      * Pick a message from input to use as the user's message
      */
@@ -269,6 +278,7 @@ export class AIAgent extends Agent {
      * which outputs structured data in YAML format within <metadata> tags.
      */
     customStructuredStreamInstructions;
+    compact;
     get inputSchema() {
         let schema = super.inputSchema;
         if (this.inputKey) {
@@ -295,7 +305,7 @@ export class AIAgent extends Agent {
         const model = this.model || options.model || options.context.model;
         if (!model)
             throw new Error("model is required to run AIAgent");
-        const { toolAgents, ...modelInput } = await this.instructions.build({
+        const { toolAgents, session, userMessage, ...modelInput } = await this.instructions.build({
             ...options,
             agent: this,
             input,
@@ -304,23 +314,23 @@ export class AIAgent extends Agent {
         modelInput.modelOptions = await model.getModelOptions(input, options);
         const toolsMap = new Map(toolAgents?.map((i) => [i.name, i]));
         if (this.toolChoice === "router") {
-            return yield* this._processRouter(input, model, modelInput, options, toolsMap);
+            return yield* this._processRouter(input, model, { messages: [...(await session.getMessages()), userMessage], ...modelInput }, options, toolsMap);
         }
-        const toolCallMessages = [];
-        const outputKey = this.outputKey;
         const inputMessage = this.inputKey ? input[this.inputKey] : undefined;
         if (inputMessage) {
             yield {
                 progress: {
                     event: "message",
-                    role: "user",
-                    message: [{ type: "text", content: inputMessage }],
+                    message: { role: "user", content: [{ type: "text", text: inputMessage }] },
                 },
             };
         }
+        await session.startMessage(input, userMessage, options);
+        // const toolCallMessages: ChatModelInputMessage[] = [];
+        const outputKey = this.outputKey;
         for (;;) {
             const modelOutput = {};
-            let stream = await this.invokeChildAgent(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { ...options, streaming: true });
+            let stream = await this.invokeChildAgent(model, { messages: await session.getMessages(), ...modelInput }, { ...options, streaming: true });
             if (this.structuredStreamMode) {
                 const { metadataStart, metadataEnd, parse } = this.customStructuredStreamInstructions || STRUCTURED_STREAM_INSTRUCTIONS;
                 stream = stream.pipeThrough(new ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
@@ -343,15 +353,19 @@ export class AIAgent extends Agent {
                 }
             }
             const { toolCalls, json, text, thoughts, files } = modelOutput;
-            if (text) {
-                yield {
-                    progress: { event: "message", role: "agent", message: [{ type: "text", content: text }] },
-                };
-            }
-            if (thoughts) {
-                yield {
-                    progress: { event: "message", role: "agent", message: [{ type: "thinking", thoughts }] },
-                };
+            if (text || thoughts) {
+                const content = [];
+                if (thoughts) {
+                    content.push({ type: "text", text: thoughts, isThinking: true });
+                }
+                if (text) {
+                    content.push({ type: "text", text });
+                }
+                if (content.length) {
+                    const message = { role: "agent", content };
+                    yield { progress: { event: "message", message } };
+                    await session.appendCurrentMessages(message);
+                }
             }
             if (toolCalls?.length) {
                 if (this.keepTextInToolUses !== true) {
@@ -383,25 +397,14 @@ export class AIAgent extends Agent {
                         queue.killAndDrain();
                     }
                 }, this.toolCallsConcurrency || 1);
+                const message = { role: "agent", toolCalls };
+                yield { progress: { event: "message", message } };
+                await session.appendCurrentMessages(message);
                 // Execute tools
                 for (const call of toolCalls) {
                     const tool = toolsMap.get(call.function.name);
                     if (!tool)
                         throw new Error(`Tool not found: ${call.function.name}`);
-                    yield {
-                        progress: {
-                            event: "message",
-                            role: "agent",
-                            message: [
-                                {
-                                    type: "tool_use",
-                                    name: call.function.name,
-                                    input: call.function.arguments,
-                                    toolUseId: call.id,
-                                },
-                            ],
-                        },
-                    };
                     queue.push({ tool, call });
                 }
                 await queue.drained();
@@ -410,24 +413,17 @@ export class AIAgent extends Agent {
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
                     for (const { call, output } of executedToolCalls) {
-                        yield {
-                            progress: {
-                                event: "message",
-                                role: "agent",
-                                message: [
-                                    {
-                                        type: "tool_result",
-                                        toolUseId: call.id,
-                                        content: output,
-                                    },
-                                ],
-                            },
+                        const message = {
+                            role: "tool",
+                            toolCallId: call.id,
+                            content: JSON.stringify(output),
                         };
+                        yield { progress: { event: "message", message: message } };
+                        await session.appendCurrentMessages(message);
                     }
                     const transferOutput = executedToolCalls.find((i) => isTransferAgentOutput(i.output))?.output;
                     if (transferOutput)
                         return transferOutput;
-                    toolCallMessages.push(await AgentMessageTemplate.from(undefined, executedToolCalls.map(({ call }) => call)).format(), ...(await Promise.all(executedToolCalls.map(({ call, output }) => ToolMessageTemplate.from(output, call.id).format()))));
                     continue;
                 }
             }
@@ -444,11 +440,7 @@ export class AIAgent extends Agent {
             if (!isEmpty(result)) {
                 yield { delta: { json: result } };
             }
-            if (text) {
-                yield {
-                    progress: { event: "message", role: "agent", message: [{ type: "text", content: text }] },
-                };
-            }
+            await session.endMessage(result, options);
             return;
         }
     }

package/lib/esm/agents/chat-model.d.ts

@@ -225,6 +225,7 @@ export type ChatModelInputMessageContent = string | UnionContent[];
 export type TextContent = {
     type: "text";
     text: string;
+    isThinking?: boolean;
     /**
      * Cache control marker (only supported by Claude)
      *

package/lib/esm/agents/image-model.d.ts

@@ -91,7 +91,6 @@ export declare const imageModelInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     modelOptions?: Record<string, unknown> | undefined;
-    outputFileType?: "local" | "url" | "file" | undefined;
     image?: ({
         type: "url";
         url: string;
@@ -109,10 +108,10 @@ export declare const imageModelInputSchema: z.ZodObject<{
         mimeType?: string | undefined;
     })[] | undefined;
     n?: number | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
 }, {
     prompt: string;
     modelOptions?: Record<string, unknown> | undefined;
-    outputFileType?: "local" | "url" | "file" | undefined;
     image?: ({
         type: "url";
         url: string;
@@ -130,6 +129,7 @@ export declare const imageModelInputSchema: z.ZodObject<{
         mimeType?: string | undefined;
     })[] | undefined;
     n?: number | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
 }>;
 export interface ImageModelOutput extends Message {
     images: FileUnionContent[];
@@ -232,6 +232,7 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[];
+    model?: string | undefined;
     usage?: {
         inputTokens: number;
         outputTokens: number;
@@ -240,7 +241,6 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
-    model?: string | undefined;
 }, {
     images: ({
         type: "url";
@@ -258,6 +258,7 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[];
+    model?: string | undefined;
     usage?: {
         inputTokens: number;
         outputTokens: number;
@@ -266,5 +267,4 @@ export declare const imageModelOutputSchema: z.ZodObject<{
         cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
-    model?: string | undefined;
 }>;

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

@@ -64,12 +64,12 @@ export declare class MCPAgent extends Agent {
         args: ZodType<string[] | undefined, z.ZodTypeDef, string[] | undefined>;
     }, "strip", z.ZodTypeAny, {
         url?: string | undefined;
-        args?: string[] | undefined;
         command?: string | undefined;
+        args?: string[] | undefined;
     }, {
         url?: string | undefined;
-        args?: string[] | undefined;
         command?: string | undefined;
+        args?: string[] | undefined;
     }>;
     static load<I extends Message = any, O extends Message = any>(options: {
         filepath: string;

package/lib/esm/agents/video-model.d.ts

@@ -94,7 +94,6 @@ export declare const videoModelInputSchema: z.ZodObject<{
     prompt: string;
     model?: string | undefined;
     modelOptions?: Record<string, unknown> | undefined;
-    outputFileType?: "local" | "url" | "file" | undefined;
     image?: {
         type: "url";
         url: string;
@@ -111,13 +110,13 @@ export declare const videoModelInputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     } | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
     size?: string | undefined;
     seconds?: string | undefined;
 }, {
     prompt: string;
     model?: string | undefined;
     modelOptions?: Record<string, unknown> | undefined;
-    outputFileType?: "local" | "url" | "file" | undefined;
     image?: {
         type: "url";
         url: string;
@@ -134,6 +133,7 @@ export declare const videoModelInputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     } | undefined;
+    outputFileType?: "local" | "file" | "url" | undefined;
     size?: string | undefined;
     seconds?: string | undefined;
 }>;
@@ -240,6 +240,7 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[];
+    model?: string | undefined;
     usage?: {
         inputTokens: number;
         outputTokens: number;
@@ -248,7 +249,6 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
-    model?: string | undefined;
     seconds?: number | undefined;
 }, {
     videos: ({
@@ -267,6 +267,7 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         filename?: string | undefined;
         mimeType?: string | undefined;
     })[];
+    model?: string | undefined;
     usage?: {
         inputTokens: number;
         outputTokens: number;
@@ -275,6 +276,5 @@ export declare const videoModelOutputSchema: z.ZodObject<{
         cacheReadInputTokens?: number | undefined;
         creditPrefix?: "$" | "€" | "¥" | undefined;
     } | undefined;
-    model?: string | undefined;
     seconds?: number | undefined;
 }>;

package/lib/esm/index.d.ts

@@ -13,6 +13,7 @@ export * from "./agents/user-agent.js";
 export * from "./agents/video-model.js";
 export * from "./aigne/index.js";
 export * from "./memory/index.js";
+export * from "./prompt/agent-session.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";
 export * from "./utils/json-utils.js";

package/lib/esm/index.js

@@ -13,6 +13,7 @@ export * from "./agents/user-agent.js";
 export * from "./agents/video-model.js";
 export * from "./aigne/index.js";
 export * from "./memory/index.js";
+export * from "./prompt/agent-session.js";
 export * from "./prompt/prompt-builder.js";
 export * from "./prompt/template.js";
 export * from "./utils/json-utils.js";

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

@@ -137,7 +137,6 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined>;
 }, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
     model?: z.objectInputType<{
         model: ZodType<string | {
             $get: string;
@@ -170,6 +169,7 @@ declare const aigneFileSchema: z.ZodObject<{
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
+    name?: string | undefined;
     description?: string | undefined;
     imageModel?: z.objectInputType<{
         model: ZodType<string | {
@@ -188,7 +188,6 @@ declare const aigneFileSchema: z.ZodObject<{
         chat?: string | undefined;
     } | undefined;
 }, {
-    name?: string | undefined;
     model?: z.objectInputType<{
         model: ZodType<string | {
             $get: string;
@@ -221,6 +220,7 @@ declare const aigneFileSchema: z.ZodObject<{
             $get: string;
         } | undefined>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
+    name?: string | undefined;
     description?: string | undefined;
     imageModel?: z.objectInputType<{
         model: ZodType<string | {

package/lib/esm/memory/recorder.d.ts

@@ -42,24 +42,24 @@ export declare const memoryRecorderOutputSchema: z.ZodObject<{
         content: ZodType<{}, z.ZodTypeDef, {}>;
         createdAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }, {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     memories: {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }[];
 }, {
     memories: {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }[];
 }>;

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

@@ -55,24 +55,24 @@ export declare const memoryRetrieverOutputSchema: z.ZodObject<{
         content: z.ZodType<{}, z.ZodTypeDef, {}>;
         createdAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }, {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     memories: {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }[];
 }, {
     memories: {
-        content: {};
         id: string;
+        content: {};
         createdAt: string;
     }[];
 }>;

package/lib/esm/prompt/agent-session.d.ts

@@ -0,0 +1,53 @@
+import type { AFS } from "@aigne/afs";
+import type { AgentInvokeOptions } from "../agents/agent.js";
+import type { ChatModelInputMessage } from "../agents/chat-model.js";
+import { type CompactConfig, type CompactContent, type EntryContent } from "./compact/types.js";
+export type { CompactConfig, CompactContent, EntryContent };
+export interface AgentSessionOptions {
+    sessionId: string;
+    userId?: string;
+    agentId?: string;
+    afs?: AFS;
+    /**
+     * Compaction configuration
+     */
+    compact?: CompactConfig;
+}
+export declare class AgentSession {
+    readonly sessionId: string;
+    readonly userId?: string;
+    readonly agentId?: string;
+    private afs?;
+    private historyModulePath?;
+    private compactConfig;
+    private runtimeState;
+    private initialized?;
+    private compactionPromise?;
+    constructor(options: AgentSessionOptions);
+    setSystemMessages(...messages: ChatModelInputMessage[]): Promise<void>;
+    getMessages(): Promise<ChatModelInputMessage[]>;
+    startMessage(input: unknown, message: ChatModelInputMessage, options: AgentInvokeOptions): Promise<void>;
+    endMessage(output: unknown, options: AgentInvokeOptions): Promise<void>;
+    /**
+     * Manually trigger compaction
+     */
+    compact(options: AgentInvokeOptions): Promise<void>;
+    /**
+     * Internal method that performs the actual compaction
+     */
+    private doCompact;
+    private maybeAutoCompact;
+    /**
+     * Estimate token count for an array of messages
+     */
+    private estimateMessagesTokens;
+    /**
+     * Split entries into batches based on token limit
+     * Each batch will not exceed the specified maxTokens
+     */
+    private splitIntoBatches;
+    appendCurrentMessages(...messages: ChatModelInputMessage[]): Promise<void>;
+    private ensureInitialized;
+    private initialize;
+    private initializeDefaultCompactor;
+}