@aigne/core 1.72.0-beta.9 → 1.72.0

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

@@ -57,7 +57,9 @@ export declare abstract class ChatModel extends Model<ChatModelInput, ChatModelO
     getModelCapabilities(): {
         supportsParallelToolCalls: boolean;
     };
+    getModelOptions(input: Message, options: AgentInvokeOptions): Promise<ChatModelInputOptions>;
     private validateToolNames;
+    countTokens(input: ChatModelInput): Promise<number>;
     /**
      * Normalizes tool names to ensure compatibility with language models
      *
@@ -226,6 +228,7 @@ export type TextContent = {
     type: "text";
     text: string;
     isThinking?: boolean;
+    isAgentSkill?: boolean;
     /**
      * Cache control marker (only supported by Claude)
      *

package/lib/esm/agents/chat-model.js

@@ -4,6 +4,7 @@ import { convertJsonSchemaToZod } from "zod-from-json-schema";
 import { optionalize } from "../loader/schema.js";
 import { wrapAutoParseJsonSchema } from "../utils/json-schema.js";
 import { logger } from "../utils/logger.js";
+import { estimateTokens } from "../utils/token-estimator.js";
 import { checkArguments, isNil, omitByDeep } from "../utils/type-utils.js";
 import { agentOptionsSchema, getterSchema, } from "./agent.js";
 import { fileContentSchema, fileUnionContentSchema, localContentSchema, Model, urlContentSchema, } from "./model.js";
@@ -80,6 +81,19 @@ export class ChatModel extends Model {
             supportsParallelToolCalls: this.supportsParallelToolCalls,
         };
     }
+    async getModelOptions(input, options) {
+        const modelOptions = (await super.getModelOptions(input, options));
+        return {
+            ...modelOptions,
+            cacheConfig: {
+                ...modelOptions.cacheConfig,
+                autoBreakpoints: {
+                    ...modelOptions.cacheConfig?.autoBreakpoints,
+                    lastMessage: modelOptions.cacheConfig?.autoBreakpoints?.lastMessage ?? true,
+                },
+            },
+        };
+    }
     validateToolNames(tools) {
         for (const tool of tools ?? []) {
             if (!/^[a-zA-Z0-9_]+$/.test(tool.function.name)) {
@@ -87,6 +101,9 @@ export class ChatModel extends Model {
             }
         }
     }
+    async countTokens(input) {
+        return estimateTokens(JSON.stringify(input));
+    }
     /**
      * Normalizes tool names to ensure compatibility with language models
      *
@@ -201,7 +218,7 @@ export class ChatModel extends Model {
             const files = z.array(fileUnionContentSchema).parse(output.files);
             output = {
                 ...output,
-                files: await Promise.all(files.map((file) => this.transformFileType(input.outputFileType, file, options))),
+                files: await Promise.all(files.map((file) => this.transformFileType(input.outputFileType, file))),
             };
         }
         // Remove fields with `null` value for validation

package/lib/esm/agents/image-model.js

@@ -67,7 +67,7 @@ export class ImageModel extends Model {
             const images = z.array(fileUnionContentSchema).parse(output.images);
             output = {
                 ...output,
-                images: await Promise.all(images.map((image) => this.transformFileType(input.outputFileType, image, options))),
+                images: await Promise.all(images.map((image) => this.transformFileType(input.outputFileType, image))),
             };
         }
         return super.processAgentOutput(input, output, options);

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

@@ -17,9 +17,9 @@ export declare abstract class Model<I extends Message = any, O extends Message =
      */
     getModelOptions(input: Message, options: AgentInvokeOptions): Promise<Record<string, unknown>>;
     protected preprocess(input: I, options: AgentInvokeOptions): Promise<void>;
-    transformFileType(fileType: "file", data: FileUnionContent, options: AgentInvokeOptions): Promise<FileContent>;
-    transformFileType(fileType: "local" | undefined, data: FileUnionContent, options: AgentInvokeOptions): Promise<LocalContent>;
-    transformFileType(fileType: FileType | undefined, data: FileUnionContent, options: AgentInvokeOptions): Promise<FileUnionContent>;
+    transformFileType(fileType: "file", data: FileUnionContent): Promise<FileContent>;
+    transformFileType(fileType: "local" | undefined, data: FileUnionContent): Promise<LocalContent>;
+    transformFileType(fileType: FileType | undefined, data: FileUnionContent): Promise<FileUnionContent>;
     static getFileExtension(type: string): Promise<string | undefined>;
     static getMimeType(filename: string): Promise<string | undefined>;
     downloadFile(url: string): Promise<Response>;

package/lib/esm/agents/model.js

@@ -53,13 +53,13 @@ export class Model extends Agent {
         Object.assign(input, { modelOptions: await this.getModelOptions(input, options) });
         return super.preprocess(input, options);
     }
-    async transformFileType(fileType = "local", data, options) {
+    async transformFileType(fileType = "local", data) {
         if (fileType === data.type)
             return data;
         const common = pick(data, "filename", "mimeType");
         switch (fileType) {
             case "local": {
-                const dir = nodejs.path.join(nodejs.os.tmpdir(), options.context.id);
+                const dir = nodejs.path.join(nodejs.os.tmpdir(), v7());
                 await nodejs.fs.mkdir(dir, { recursive: true });
                 const ext = await Model.getFileExtension(data.mimeType || data.filename || "");
                 const id = v7();

package/lib/esm/agents/video-model.js

@@ -40,7 +40,7 @@ export class VideoModel extends Model {
             const videos = z.array(fileUnionContentSchema).parse(output.videos);
             output = {
                 ...output,
-                videos: await Promise.all(videos.map((video) => this.transformFileType(input.outputFileType, video, options))),
+                videos: await Promise.all(videos.map((video) => this.transformFileType(input.outputFileType, video))),
             };
         }
         return super.processAgentOutput(input, output, options);

package/lib/esm/aigne/context.js

@@ -10,7 +10,7 @@ import { AgentResponseProgressStream } from "../utils/event-stream.js";
 import { logger } from "../utils/logger.js";
 import { promiseWithResolvers } from "../utils/promise.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, mergeReadableStreams, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
-import { checkArguments, flat, isEmpty, isNil, omit, } from "../utils/type-utils.js";
+import { checkArguments, flat, isEmpty, isNil, omit, pick, } from "../utils/type-utils.js";
 import { MessageQueue, toMessagePayload, } from "./message-queue.js";
 import { newEmptyContextUsage } from "./usage.js";
 /**
@@ -340,11 +340,9 @@ class AIGNEContextShared {
                     }
                 }
                 const stream = await activeAgent.invoke(input, {
-                    hooks: options.hooks,
+                    ...pick(options, "hooks", "model", "imageModel", "caller"),
                     context,
                     streaming: true,
-                    model: options.model,
-                    imageModel: options.imageModel,
                 });
                 for await (const value of stream) {
                     if (isAgentResponseDelta(value)) {

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

@@ -1,17 +1,36 @@
 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 };
+import { type CompactConfig, type SessionMemoryConfig, type SessionMode, type UserMemoryConfig } from "./compact/types.js";
+export * from "./compact/types.js";
 export interface AgentSessionOptions {
     sessionId: string;
     userId?: string;
     agentId?: string;
     afs?: AFS;
+    /**
+     * Session mode
+     * - "auto": Enable history recording, compaction, and memory extraction
+     * - "disabled": Disable all session features (history, compaction, memory)
+     *
+     * **Should be "disabled" for internal utility agents** (extractors, compactors, etc.)
+     * to avoid recursive memory extraction and unnecessary overhead.
+     *
+     * @default DEFAULT_SESSION_MODE ("auto")
+     */
+    mode?: SessionMode;
     /**
      * Compaction configuration
      */
     compact?: CompactConfig;
+    /**
+     * Session memory configuration
+     */
+    sessionMemory?: SessionMemoryConfig;
+    /**
+     * User memory configuration
+     */
+    userMemory?: UserMemoryConfig;
 }
 export declare class AgentSession {
     readonly sessionId: string;
@@ -19,15 +38,36 @@ export declare class AgentSession {
     readonly agentId?: string;
     private afs?;
     private historyModulePath?;
+    private mode;
     private compactConfig;
+    private sessionMemoryConfig;
+    private userMemoryConfig;
     private runtimeState;
     private initialized?;
     private compactionPromise?;
+    private sessionMemoryUpdatePromise?;
+    private userMemoryUpdatePromise?;
     constructor(options: AgentSessionOptions);
+    /**
+     * Check if memory extraction is enabled
+     * Memory extraction requires mode to be "auto" AND AFS history module to be available
+     */
+    private get isMemoryEnabled();
     setSystemMessages(...messages: ChatModelInputMessage[]): Promise<void>;
     getMessages(): Promise<ChatModelInputMessage[]>;
+    /**
+     * Format user memory facts into a system message
+     * Applies token budget limit to ensure memory injection fits within constraints
+     */
+    private formatUserMemory;
+    /**
+     * Format session memory facts into a system message
+     * Applies token budget limit to ensure memory injection fits within constraints
+     */
+    private formatSessionMemory;
+    private formatMemoryTemplate;
     startMessage(input: unknown, message: ChatModelInputMessage, options: AgentInvokeOptions): Promise<void>;
-    endMessage(output: unknown, options: AgentInvokeOptions): Promise<void>;
+    endMessage(output: unknown, message: ChatModelInputMessage | undefined, options: AgentInvokeOptions): Promise<void>;
     /**
      * Manually trigger compaction
      */
@@ -36,9 +76,13 @@ export declare class AgentSession {
      * Internal method that performs the actual compaction
      */
     private doCompact;
+    private compactCurrentEntry;
+    private maybeCompactCurrentEntry;
     private maybeAutoCompact;
     /**
-     * Estimate token count for an array of messages
+     * Estimate token count for messages
+     * Applies singleMessageLimit to each text block individually
+     * Non-text tokens (images, tool calls) are always counted in full
      */
     private estimateMessagesTokens;
     /**
@@ -46,8 +90,74 @@ export declare class AgentSession {
      * Each batch will not exceed the specified maxTokens
      */
     private splitIntoBatches;
-    appendCurrentMessages(...messages: ChatModelInputMessage[]): Promise<void>;
+    appendCurrentMessages(messages: ChatModelInputMessage | ChatModelInputMessage[], options: AgentInvokeOptions): Promise<void>;
+    /**
+     * Truncate text content to fit within target token limit
+     * @param text The text to truncate
+     * @param currentTokens Current token count of the text
+     * @param targetTokens Target token count after truncation
+     * @returns Truncated text
+     */
+    private truncateText;
+    private truncateLargeMessage;
     private ensureInitialized;
     private initialize;
+    /**
+     * Load session memory facts
+     * @returns Array of memory fact entries for the current session
+     */
+    private loadSessionMemory;
+    /**
+     * Load user memory facts
+     * @returns Array of memory fact entries for the current user
+     */
+    private loadUserMemory;
+    /**
+     * Load session history including compact content and history entries
+     * @returns Object containing history compact and history entries
+     */
+    private loadSessionHistory;
+    /**
+     * Manually trigger session memory update
+     */
+    updateSessionMemory(options: AgentInvokeOptions): Promise<void>;
+    private maybeAutoUpdateSessionMemory;
+    private maybeAutoUpdateUserMemory;
+    /**
+     * Internal method that performs the actual session memory update
+     */
+    private doUpdateSessionMemory;
+    /**
+     * Manually trigger user memory update
+     */
+    updateUserMemory(options: AgentInvokeOptions): Promise<void>;
+    /**
+     * Internal method that performs the actual user memory extraction
+     */
+    private doUpdateUserMemory;
+    /**
+     * Find Agent Skill content from a single message
+     * @param msg - Message to search in
+     * @returns The skill content text if found, undefined otherwise
+     */
+    private findSkillContentInMessage;
+    /**
+     * Find the last Agent Skill from a list of messages
+     * @param messages - Messages to search through
+     * @returns The last Agent Skill found, or undefined if none found
+     */
+    private findLastAgentSkillFromMessages;
+    /**
+     * Find the last Agent Skill from a list of history entries
+     * @param entries - History entries to search through
+     * @returns The last Agent Skill found, or undefined if none found
+     */
+    private findLastAgentSkill;
     private initializeDefaultCompactor;
+    private initializeDefaultSessionMemoryExtractor;
+    private initializeDefaultUserMemoryExtractor;
+    private get maxTokens();
+    private get keepRecentRatio();
+    private get keepRecentTokens();
+    private get singleMessageLimit();
 }