@aigne/core 1.72.0-beta.9 → 1.72.0

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

@@ -39,6 +39,7 @@ const agent_yaml_js_1 = require("../loader/agent-yaml.js");
 const schema_js_1 = require("../loader/schema.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const structured_stream_instructions_js_1 = require("../prompt/prompts/structured-stream-instructions.js");
+const agent_skill_js_1 = require("../prompt/skills/afs/agent-skill/agent-skill.js");
 const fastq = __importStar(require("../utils/queue.js"));
 const stream_utils_js_1 = require("../utils/stream-utils.js");
 const structured_stream_extractor_js_1 = require("../utils/structured-stream-extractor.js");
@@ -125,7 +126,7 @@ class AIAgent extends agent_js_1.Agent {
     static schema({ filepath }) {
         const instructionsSchema = (0, schema_js_1.getInstructionsSchema)({ filepath });
         const nestAgentSchema = (0, agent_yaml_js_1.getNestAgentSchema)({ filepath });
-        return (0, schema_js_1.camelizeSchema)(zod_1.z.object({
+        const schema = (0, schema_js_1.camelizeSchema)(zod_1.z.object({
             instructions: (0, schema_js_1.optionalize)(instructionsSchema),
             inputKey: (0, schema_js_1.optionalize)(zod_1.z.string()),
             outputKey: (0, schema_js_1.optionalize)(zod_1.z.string()),
@@ -136,28 +137,75 @@ class AIAgent extends agent_js_1.Agent {
             keepTextInToolUses: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
             catchToolsError: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
             structuredStreamMode: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
-            compact: (0, schema_js_1.camelizeSchema)((0, schema_js_1.optionalize)(zod_1.z.object({
+            session: (0, schema_js_1.optionalize)((0, schema_js_1.camelizeSchema)(zod_1.z.object({
                 mode: (0, schema_js_1.optionalize)(zod_1.z.enum(["auto", "disabled"])),
-                maxTokens: zod_1.z.number().int().min(0).optional(),
-                keepRecentRatio: (0, schema_js_1.optionalize)(zod_1.z.number().min(0).max(1)),
-                async: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
-                compactor: (0, schema_js_1.optionalize)(nestAgentSchema),
+                sessionMemory: (0, schema_js_1.optionalize)((0, schema_js_1.camelizeSchema)(zod_1.z.object({
+                    mode: (0, schema_js_1.optionalize)(zod_1.z.enum(["auto", "disabled"])),
+                    memoryRatio: (0, schema_js_1.optionalize)(zod_1.z.number().min(0).max(1)),
+                    queryLimit: (0, schema_js_1.optionalize)(zod_1.z.number().int().min(0)),
+                    async: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
+                    extractor: (0, schema_js_1.optionalize)(nestAgentSchema),
+                }))),
+                userMemory: (0, schema_js_1.optionalize)((0, schema_js_1.camelizeSchema)(zod_1.z.object({
+                    mode: (0, schema_js_1.optionalize)(zod_1.z.enum(["auto", "disabled"])),
+                    memoryRatio: (0, schema_js_1.optionalize)(zod_1.z.number().min(0).max(1)),
+                    queryLimit: (0, schema_js_1.optionalize)(zod_1.z.number().int().min(0)),
+                    async: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
+                    extractor: (0, schema_js_1.optionalize)(nestAgentSchema),
+                }))),
+                compact: (0, schema_js_1.optionalize)((0, schema_js_1.camelizeSchema)(zod_1.z.object({
+                    mode: (0, schema_js_1.optionalize)(zod_1.z.enum(["auto", "disabled"])),
+                    maxTokens: zod_1.z.number().int().min(0).optional(),
+                    keepRecentRatio: (0, schema_js_1.optionalize)(zod_1.z.number().min(0).max(1)),
+                    async: (0, schema_js_1.optionalize)(zod_1.z.boolean()),
+                    compactor: (0, schema_js_1.optionalize)(nestAgentSchema),
+                }))),
             }))),
         }));
+        return schema;
     }
     static async load(options) {
         const schema = AIAgent.schema(options);
         const valid = await schema.parseAsync(options.parsed);
+        // Load nested agents from session config if present
+        const sessionCompactor = valid.session?.compact?.compactor
+            ? await options.options?.loadNestAgent(options.filepath, valid.session.compact.compactor, options.options)
+            : undefined;
+        const sessionMemoryExtractor = valid.session?.sessionMemory?.extractor
+            ? await options.options?.loadNestAgent(options.filepath, valid.session.sessionMemory.extractor, options.options)
+            : undefined;
+        const userMemoryExtractor = valid.session?.userMemory?.extractor
+            ? await options.options?.loadNestAgent(options.filepath, valid.session.userMemory.extractor, options.options)
+            : undefined;
+        // Build session configuration with loaded agents
+        const sessionConfig = valid.session
+            ? {
+                ...valid.session,
+                compact: valid.session.compact
+                    ? {
+                        ...valid.session.compact,
+                        compactor: sessionCompactor,
+                    }
+                    : undefined,
+                sessionMemory: valid.session.sessionMemory
+                    ? {
+                        ...valid.session.sessionMemory,
+                        extractor: sessionMemoryExtractor,
+                    }
+                    : undefined,
+                userMemory: valid.session.userMemory
+                    ? {
+                        ...valid.session.userMemory,
+                        extractor: userMemoryExtractor,
+                    }
+                    : undefined,
+            }
+            : undefined;
         return new AIAgent({
             ...options.parsed,
             ...valid,
             instructions: valid.instructions && (0, schema_js_1.instructionsToPromptBuilder)(valid.instructions),
-            compact: {
-                ...valid.compact,
-                compactor: valid.compact?.compactor
-                    ? await options.options?.loadNestAgent(options.filepath, valid.compact.compactor, options.options)
-                    : undefined,
-            },
+            session: sessionConfig,
         });
     }
     /**
@@ -198,7 +246,7 @@ class AIAgent extends agent_js_1.Agent {
         this.memoryAgentsAsTools = options.memoryAgentsAsTools;
         this.memoryPromptTemplate = options.memoryPromptTemplate;
         this.useMemoriesFromContext = options.useMemoriesFromContext;
-        this.compact = options.compact;
+        this.session = options.session;
         if (typeof options.catchToolsError === "boolean")
             this.catchToolsError = options.catchToolsError;
         this.structuredStreamMode = options.structuredStreamMode;
@@ -314,7 +362,10 @@ class AIAgent extends agent_js_1.Agent {
      * which outputs structured data in YAML format within <metadata> tags.
      */
     customStructuredStreamInstructions;
-    compact;
+    /**
+     * Agent session configuration
+     */
+    session;
     get inputSchema() {
         let schema = super.inputSchema;
         if (this.inputKey) {
@@ -400,16 +451,27 @@ class AIAgent extends agent_js_1.Agent {
                 if (content.length) {
                     const message = { role: "agent", content };
                     yield { progress: { event: "message", message } };
-                    await session.appendCurrentMessages(message);
+                    await session.appendCurrentMessages(message, options);
                 }
             }
-            if (toolCalls?.length) {
+            const toolCallsWithTools = toolCalls?.map((call) => {
+                const tool = toolsMap.get(call.function.name);
+                if (!tool)
+                    throw new Error(`Tool not found: ${call.function.name}`);
+                return {
+                    ...call,
+                    tool,
+                };
+            });
+            if (toolCallsWithTools?.length) {
                 if (this.keepTextInToolUses !== true) {
                     yield { delta: { json: { [outputKey]: "" } } };
                 }
                 else {
                     yield { delta: { text: { [outputKey]: "\n\n" } } };
                 }
+                const toolCallMessage = { role: "agent", toolCalls };
+                yield { progress: { event: "message", message: toolCallMessage } };
                 const executedToolCalls = [];
                 let error;
                 const queue = fastq.promise(async ({ tool, call }) => {
@@ -426,40 +488,38 @@ class AIAgent extends agent_js_1.Agent {
                                 },
                             };
                         });
-                        executedToolCalls.push({ call, output });
+                        executedToolCalls.push({ call, tool, output });
                     }
                     catch (e) {
                         error = e;
                         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}`);
-                    queue.push({ tool, call });
+                for (const call of toolCallsWithTools) {
+                    queue.push({ tool: call.tool, call });
                 }
                 await queue.drained();
                 if (error)
                     throw error;
+                const toolResultMessages = [];
                 // Continue LLM function calling loop if any tools were executed
                 if (executedToolCalls.length) {
-                    for (const { call, output } of executedToolCalls) {
+                    for (const { call, tool, output } of executedToolCalls) {
+                        const isAgentSkill = !output.isError && tool instanceof agent_skill_js_1.AgentSkill ? true : undefined;
+                        const text = await tool.formatOutput(output);
                         const message = {
                             role: "tool",
                             toolCallId: call.id,
-                            content: JSON.stringify(output),
+                            content: [{ type: "text", text, isAgentSkill }],
                         };
                         yield { progress: { event: "message", message: message } };
-                        await session.appendCurrentMessages(message);
+                        toolResultMessages.push(message);
                     }
                     const transferOutput = executedToolCalls.find((i) => (0, types_js_1.isTransferAgentOutput)(i.output))?.output;
                     if (transferOutput)
                         return transferOutput;
+                    await session.appendCurrentMessages([toolCallMessage, ...toolResultMessages], options);
                     continue;
                 }
             }
@@ -476,7 +536,7 @@ class AIAgent extends agent_js_1.Agent {
             if (!(0, type_utils_js_1.isEmpty)(result)) {
                 yield { delta: { json: result } };
             }
-            await session.endMessage(result, options);
+            await session.endMessage(result, undefined, options);
             return;
         }
     }

package/lib/cjs/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/cjs/agents/chat-model.js

@@ -40,6 +40,7 @@ const zod_from_json_schema_1 = require("zod-from-json-schema");
 const schema_js_1 = require("../loader/schema.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const logger_js_1 = require("../utils/logger.js");
+const token_estimator_js_1 = require("../utils/token-estimator.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_1 = require("./agent.js");
 const model_js_1 = require("./model.js");
@@ -117,6 +118,19 @@ class ChatModel extends model_js_1.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)) {
@@ -124,6 +138,9 @@ class ChatModel extends model_js_1.Model {
             }
         }
     }
+    async countTokens(input) {
+        return (0, token_estimator_js_1.estimateTokens)(JSON.stringify(input));
+    }
     /**
      * Normalizes tool names to ensure compatibility with language models
      *
@@ -238,7 +255,7 @@ class ChatModel extends model_js_1.Model {
             const files = zod_1.z.array(model_js_1.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/cjs/agents/image-model.js

@@ -70,7 +70,7 @@ class ImageModel extends model_js_1.Model {
             const images = zod_1.z.array(model_js_1.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/cjs/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/cjs/agents/model.js

@@ -89,13 +89,13 @@ class Model extends agent_js_1.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 = (0, type_utils_js_1.pick)(data, "filename", "mimeType");
         switch (fileType) {
             case "local": {
-                const dir = index_js_1.nodejs.path.join(index_js_1.nodejs.os.tmpdir(), options.context.id);
+                const dir = index_js_1.nodejs.path.join(index_js_1.nodejs.os.tmpdir(), (0, uuid_1.v7)());
                 await index_js_1.nodejs.fs.mkdir(dir, { recursive: true });
                 const ext = await Model.getFileExtension(data.mimeType || data.filename || "");
                 const id = (0, uuid_1.v7)();

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

@@ -43,7 +43,7 @@ class VideoModel extends model_js_1.Model {
             const videos = zod_1.z.array(model_js_1.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/cjs/aigne/context.js

@@ -347,11 +347,9 @@ class AIGNEContextShared {
                     }
                 }
                 const stream = await activeAgent.invoke(input, {
-                    hooks: options.hooks,
+                    ...(0, type_utils_js_1.pick)(options, "hooks", "model", "imageModel", "caller"),
                     context,
                     streaming: true,
-                    model: options.model,
-                    imageModel: options.imageModel,
                 });
                 for await (const value of stream) {
                     if ((0, agent_js_1.isAgentResponseDelta)(value)) {

package/lib/cjs/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();
 }