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

package/lib/dts/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/dts/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/dts/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/dts/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;
+}

package/lib/dts/prompt/compact/compactor.d.ts

@@ -0,0 +1,7 @@
+import { AIAgent, type AIAgentOptions } from "../../agents/ai-agent.js";
+import type { CompactContent, CompactorInput } from "./types.js";
+export interface CreateCompactorOptions extends AIAgentOptions<CompactorInput, CompactContent> {
+}
+export declare class AISessionCompactor extends AIAgent<CompactorInput, CompactContent> {
+    constructor(options?: CreateCompactorOptions);
+}

package/lib/dts/prompt/compact/types.d.ts

@@ -0,0 +1,79 @@
+import type { Agent, Message } from "../../agents/agent.js";
+import type { ChatModelInputMessage } from "../../agents/chat-model.js";
+/**
+ * Default compaction mode
+ */
+export declare const DEFAULT_COMPACT_MODE: "auto";
+/**
+ * Default maximum tokens before triggering compaction
+ */
+export declare const DEFAULT_MAX_TOKENS = 80000;
+/**
+ * Default ratio of maxTokens to reserve for keeping recent messages
+ */
+export declare const DEFAULT_KEEP_RECENT_RATIO = 0.5;
+/**
+ * Default async mode for compaction
+ */
+export declare const DEFAULT_COMPACT_ASYNC = true;
+/**
+ * Content structure for history entries
+ */
+export interface EntryContent {
+    input?: unknown;
+    output?: unknown;
+    messages?: ChatModelInputMessage[];
+}
+/**
+ * Output structure from the compactor agent
+ */
+export interface CompactContent extends Message {
+    summary: string;
+}
+/**
+ * Input structure for the compactor agent
+ */
+export interface CompactorInput extends Message {
+    previousSummary?: string[];
+    messages: ChatModelInputMessage[];
+}
+/**
+ * Type alias for a compactor agent
+ */
+export type Compactor = Agent<CompactorInput, CompactContent>;
+/**
+ * Configuration for session compaction
+ */
+export interface CompactConfig {
+    /**
+     * Compaction mode
+     * @default DEFAULT_COMPACT_MODE ("auto")
+     */
+    mode?: "auto" | "disabled";
+    /**
+     * Maximum tokens before triggering compaction
+     * @default DEFAULT_MAX_TOKENS (80000)
+     */
+    maxTokens?: number;
+    /**
+     * Ratio of maxTokens to reserve for keeping recent messages (0-1)
+     *
+     * Defines what portion of maxTokens budget should be allocated for
+     * preserving recent conversation history without compaction.
+     *
+     * @default 0.5 (50% of maxTokens)
+     * @example 0.5 means if maxTokens=80000, keep up to 40000 tokens of recent messages
+     */
+    keepRecentRatio?: number;
+    /**
+     * Whether to perform compaction asynchronously
+     * @default DEFAULT_COMPACT_ASYNC (true)
+     */
+    async?: boolean;
+    /**
+     * Agent that generates summaries from conversation entries
+     * Input: { entries: EntryContent[] }
+     * Output: { summary: string }
+     */
+    compactor?: Compactor;
+}

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

@@ -1,9 +1,10 @@
 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 ChatModel, type ChatModelInput, type ChatModelInputMessage } from "../agents/chat-model.js";
+import type { ChatModel, ChatModelInput, ChatModelInputMessage } from "../agents/chat-model.js";
 import { type FileUnionContent } from "../agents/model.js";
 import type { Context } from "../aigne/context.js";
+import { AgentSession } from "./agent-session.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
     instructions?: string | ChatMessagesTemplate;
@@ -28,7 +29,9 @@ export declare class PromptBuilder {
     instructions?: string | ChatMessagesTemplate;
     workingDir?: string;
     copy(): PromptBuilder;
-    build(options: PromptBuildOptions): Promise<ChatModelInput & {
+    build(options: PromptBuildOptions): Promise<Omit<ChatModelInput, "messages"> & {
+        session: AgentSession;
+        userMessage: ChatModelInputMessage;
         toolAgents?: Agent[];
     }>;
     buildPrompt(options: Pick<PromptBuildOptions, "input" | "context"> & {
@@ -39,13 +42,8 @@ export declare class PromptBuilder {
     }>;
     private getTemplateVariables;
     private buildMessages;
+    private mergeMessages;
     protected deprecatedMemories(message: string | undefined, options: PromptBuildOptions): Promise<ChatModelInputMessage[]>;
-    getHistories({ agentId, userId, sessionId, ...options }: PromptBuildOptions & {
-        agentId?: string;
-        userId?: string;
-        sessionId?: string;
-    }): Promise<ChatModelInputMessage[]>;
-    private refineMessages;
     private convertMemoriesToMessages;
     private buildResponseFormat;
     private buildTools;

package/lib/dts/prompt/template.d.ts

@@ -42,7 +42,7 @@ export declare class AgentMessageTemplate extends ChatMessageTemplate {
     static from(template?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[], name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): AgentMessageTemplate;
     constructor(content?: ChatModelInputMessage["content"], toolCalls?: ChatModelOutputToolCall[] | undefined, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]);
     format(_variables?: Record<string, unknown>, _options?: FormatOptions): Promise<{
-        role: "system" | "user" | "agent" | "tool";
+        role: "agent" | "user" | "system" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCalls: ChatModelOutputToolCall[] | undefined;
@@ -54,7 +54,7 @@ export declare class ToolMessageTemplate extends ChatMessageTemplate {
     static from(content: object | string, toolCallId: string, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]): ToolMessageTemplate;
     constructor(content: object | string, toolCallId: string, name?: string, options?: FormatOptions, cacheControl?: ChatModelInputMessage["cacheControl"]);
     format(_variables?: Record<string, unknown>, _options?: FormatOptions): Promise<{
-        role: "system" | "user" | "agent" | "tool";
+        role: "agent" | "user" | "system" | "tool";
         name: string | undefined;
         content: ChatModelInputMessageContent | undefined;
         toolCallId: string;
@@ -83,21 +83,21 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "system";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string;
     role: "system";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"user">;
     content: z.ZodString;
@@ -113,21 +113,21 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "user";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string;
     role: "user";
+    content: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"agent">;
     content: z.ZodOptional<z.ZodString>;
@@ -172,6 +172,7 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     role: "agent";
+    name?: string | undefined;
     content?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
@@ -185,9 +186,9 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         type: "function";
         id: string;
     }[] | undefined;
-    name?: string | undefined;
 }, {
     role: "agent";
+    name?: string | undefined;
     content?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
@@ -201,7 +202,6 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         type: "function";
         id: string;
     }[] | undefined;
-    name?: string | undefined;
 }>, z.ZodObject<{
     role: z.ZodLiteral<"tool">;
     content: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>, string, string | Record<string, unknown>>;
@@ -218,23 +218,23 @@ declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{
         ttl?: "5m" | "1h" | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    content: string;
     role: "tool";
+    content: string;
     toolCallId: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }, {
-    content: string | Record<string, unknown>;
     role: "tool";
+    content: string | Record<string, unknown>;
     toolCallId: string;
+    name?: string | undefined;
     cacheControl?: {
         type: "ephemeral";
         ttl?: "5m" | "1h" | undefined;
     } | undefined;
-    name?: string | undefined;
 }>]>;
 export declare function safeParseChatMessages(messages: unknown): ChatMessageTemplate[] | undefined;
 export declare function parseChatMessages(messages: (z.infer<typeof chatMessageSchema> & {

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

@@ -118,7 +118,6 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * agentSucceed, or agentFailed
      */
     disableEvents?: boolean;
-    historyConfig?: Agent["historyConfig"];
     /**
      * One or more memory agents this agent can use
      */
@@ -211,15 +210,15 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
         parsed: object;
     }): Promise<Agent<I, O>>;
     constructor(options?: AgentOptions<I, O>);
+    afs?: AFS;
+    tag?: string;
     /**
      * List of memories this agent can use
      *
      * @deprecated use afs instead
      */
     readonly memories: MemoryAgent[];
-    afs?: AFS;
     asyncMemoryRecord?: boolean;
-    tag?: string;
     /**
      * Maximum number of memory items to retrieve
      */
@@ -349,24 +348,6 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * agentSucceed, or agentFailed
      */
     private disableEvents?;
-    historyConfig?: {
-        /**
-         * Whether to enable history recording and injection
-         * @default false
-         */
-        enabled?: boolean;
-        /**
-         * Whether to record history entries, default to enabled when history is enabled
-         */
-        record?: boolean;
-        /**
-         * Whether to inject history entries into the context, default to enabled when history is enabled
-         */
-        inject?: boolean;
-        useOldMemory?: boolean;
-        maxTokens?: number;
-        maxItems?: number;
-    };
     private subscriptions;
     /**
      * Attach agent to context:

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:
@@ -532,17 +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?.record === true ||
-            (this.historyConfig?.record !== false && this.historyConfig?.enabled)) {
-            this.afs?.emit("agentSucceed", {
-                agentId: this.name,
-                userId: context.userContext.userId,
-                sessionId: context.userContext.sessionId,
-                input,
-                output: finalOutput,
-                messages,
-            });
-        }
+        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