@aigne/core 1.72.0-beta.9 → 1.72.0

package/lib/cjs/prompt/skills/afs/agent-skill/skill-loader.js

@@ -3,10 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadSkill = loadSkill;
-exports.loadSkills = loadSkills;
+exports.discoverSkillsFromAFS = discoverSkillsFromAFS;
 exports.loadAgentSkillFromAFS = loadAgentSkillFromAFS;
-const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
 const front_matter_1 = __importDefault(require("front-matter"));
 const agent_skill_js_1 = require("./agent-skill.js");
 function parseSkill(content, path) {
@@ -18,42 +16,32 @@ function parseSkill(content, path) {
         content: meta.body,
     };
 }
-async function loadSkill(path) {
-    const entry = index_js_1.nodejs.path.join(path, "SKILL.md");
-    const skill = await index_js_1.nodejs.fs.readFile(entry, "utf-8");
-    return parseSkill(skill, path);
-}
-async function loadSkills(paths) {
-    const skills = [];
-    for (const path of paths) {
-        const skill = await loadSkill(path);
-        skills.push(skill);
-    }
-    return skills;
-}
-async function loadAgentSkillFromAFS({ afs, }) {
+async function discoverSkillsFromAFS(afs) {
     const modules = await afs.listModules();
-    const filtered = modules.filter(({ module: m }) => "options" in m &&
-        typeof m.options === "object" &&
-        m.options &&
-        "agentSkills" in m.options &&
-        m.options.agentSkills === true);
+    const filtered = modules.filter(({ module: m }) => m.agentSkills === true);
     if (!filtered.length)
-        return;
+        return [];
     const skills = [];
     for (const module of filtered) {
-        const data = (await afs.list(module.path, {
+        const data = (await afs
+            .list(module.path, {
             pattern: "**/SKILL.md",
             maxDepth: 10,
-        })).data;
+        })
+            .catch(() => ({ data: [] }))).data;
         for (const entry of data) {
             const { data: file } = await afs.read(entry.path);
             if (typeof file?.content !== "string")
                 continue;
-            const skill = parseSkill(file.content, index_js_1.nodejs.path.dirname(entry.path));
+            const dirname = entry.path.split("/").slice(0, -1).join("/");
+            const skill = parseSkill(file.content, dirname);
             skills.push(skill);
         }
     }
+    return skills;
+}
+async function loadAgentSkillFromAFS({ afs, }) {
+    const skills = await discoverSkillsFromAFS(afs);
     if (!skills.length)
         return;
     return new agent_skill_js_1.AgentSkill({

package/lib/cjs/prompt/skills/afs/list.d.ts

@@ -1,5 +1,6 @@
 import type { AFSListOptions } from "@aigne/afs";
 import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
+import type { PromiseOrValue } from "../../../utils/type-utils.js";
 import { AFSSkillBase } from "./base.js";
 export interface AFSListInput extends Message {
     path: string;
@@ -18,5 +19,6 @@ export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListO
 }
 export declare class AFSListAgent extends AFSSkillBase<AFSListInput, AFSListOutput> {
     constructor(options: AFSListAgentOptions);
+    formatOutput(output: AFSListOutput): PromiseOrValue<string>;
     process(input: AFSListInput, _options: AgentInvokeOptions): Promise<AFSListOutput>;
 }

package/lib/cjs/prompt/skills/afs/list.js

@@ -56,10 +56,18 @@ Usage:
             }),
         });
     }
+    formatOutput(output) {
+        if (typeof output.data === "string")
+            return output.data;
+        return super.formatOutput(output);
+    }
     async process(input, _options) {
         if (!this.afs)
             throw new Error("AFS is not configured for this agent.");
-        const { data, message } = await this.afs.list(input.path, input.options);
+        const { data, message } = await this.afs.list(input.path, {
+            ...input.options,
+            format: "simple-list",
+        });
         return {
             status: "success",
             tool: "afs_list",

package/lib/cjs/prompt/skills/afs/read.d.ts

@@ -1,5 +1,6 @@
 import type { AFSEntry } from "@aigne/afs";
 import type { AgentInvokeOptions, AgentOptions, Message } from "../../../agents/agent.js";
+import type { PromiseOrValue } from "../../../utils/type-utils.js";
 import { AFSSkillBase } from "./base.js";
 export interface AFSReadInput extends Message {
     path: string;
@@ -10,7 +11,7 @@ export interface AFSReadOutput extends Message {
     status: string;
     tool: string;
     path: string;
-    data?: AFSEntry;
+    data?: AFSEntry | null;
     message?: string;
     totalLines?: number;
     returnedLines?: number;
@@ -22,5 +23,6 @@ export interface AFSReadAgentOptions extends AgentOptions<AFSReadInput, AFSReadO
 }
 export declare class AFSReadAgent extends AFSSkillBase<AFSReadInput, AFSReadOutput> {
     constructor(options: AFSReadAgentOptions);
+    formatOutput(output: AFSReadOutput): PromiseOrValue<string>;
     process(input: AFSReadInput, _options: AgentInvokeOptions): Promise<AFSReadOutput>;
 }

package/lib/cjs/prompt/skills/afs/read.js

@@ -51,6 +51,11 @@ Usage:
             }),
         });
     }
+    formatOutput(output) {
+        if (typeof output.data?.content === "string" && output.data.content)
+            return output.data.content;
+        return super.formatOutput({ ...output, data: output.data || null });
+    }
     async process(input, _options) {
         if (!this.afs)
             throw new Error("AFS is not configured for this agent.");

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

@@ -48,5 +48,5 @@ function resourceFromMCPResource(resource, options) {
     });
 }
 function isResourceTemplate(resource) {
-    return typeof resource.uriTemplate === "string";
+    return "uriTemplate" in resource && typeof resource.uriTemplate === "string";
 }

package/lib/cjs/utils/token-estimator.js

@@ -8,7 +8,7 @@ exports.estimateTokens = estimateTokens;
 const CHAR_TYPE_RATIOS = {
     chinese: 1.5, // Chinese characters: ~1.5 characters per token
     word: 0.75, // English words: ~0.75 tokens per word (accounting for subword tokenization)
-    other: 4, // Other characters (punctuation, numbers, etc.): ~4 characters per token
+    other: 1, // Other characters (punctuation, numbers, etc.): ~1 character per token
 };
 /**
  * Regular expressions for character type detection

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

@@ -58,7 +58,6 @@ function duplicates(arr, key = (item) => item) {
 function remove(arr, remove) {
     const removed = [];
     for (let i = 0; i < arr.length; i++) {
-        // biome-ignore lint/style/noNonNullAssertion: false positive
         const item = arr[i];
         if ((Array.isArray(remove) && remove.includes(item)) ||
             (typeof remove === "function" && remove(item))) {

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

@@ -172,6 +172,10 @@ export interface AgentInvokeOptions<U extends UserContext = UserContext> {
      * This property only exists in the CLI context by command `aigne run`
      */
     prompts?: typeof prompts;
+    /**
+     * The caller agent that invoked this agent
+     */
+    caller?: Agent;
 }
 /**
  * Agent is the base class for all agents.
@@ -513,6 +517,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      */
     protected postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
     protected publishToTopics(output: Message, options: AgentInvokeOptions): Promise<void>;
+    formatOutput(output: O): PromiseOrValue<string>;
     /**
      * Core processing method of the agent, must be implemented in subclasses
      *

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

@@ -2,7 +2,7 @@ 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 type { CompactConfig, SessionMemoryConfig, UserMemoryConfig } 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";
@@ -126,7 +126,31 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
      */
     memoryPromptTemplate?: string;
     useMemoriesFromContext?: boolean;
-    compact?: CompactConfig;
+    /**
+     * Agent session configuration
+     *
+     * Controls history recording, memory extraction, and conversation compaction.
+     * By default, mode is "auto" (enabled). Set `{ mode: "disabled" }` to disable
+     * for internal utility agents (extractors, compactors, etc.).
+     *
+     * @example
+     * ```typescript
+     * // Default behavior - session features enabled
+     * new AIAgent({
+     *   session: {
+     *     compact: { mode: "auto" },
+     *     sessionMemory: { mode: "auto" },
+     *     userMemory: { mode: "auto" }
+     *   }
+     * })
+     *
+     * // Disable for internal utility agents
+     * new AIAgent({
+     *   session: { mode: "disabled" }
+     * })
+     * ```
+     */
+    session?: Partial<Omit<import("../prompt/agent-session.js").AgentSessionOptions, "sessionId" | "userId" | "agentId" | "afs">>;
 }
 export interface AIAgentLoadSchema {
     instructions?: Instructions;
@@ -137,8 +161,17 @@ export interface AIAgentLoadSchema {
     toolChoice?: AIAgentToolChoice;
     toolCallsConcurrency?: number;
     keepTextInToolUses?: boolean;
-    compact?: Omit<CompactConfig, "compactor"> & {
-        compactor?: NestAgentSchema;
+    session?: {
+        mode?: "auto" | "disabled";
+        compact?: Omit<CompactConfig, "compactor"> & {
+            compactor?: NestAgentSchema;
+        };
+        sessionMemory?: Omit<SessionMemoryConfig, "extractor"> & {
+            extractor?: NestAgentSchema;
+        };
+        userMemory?: Omit<UserMemoryConfig, "extractor"> & {
+            extractor?: NestAgentSchema;
+        };
     };
 }
 /**
@@ -337,7 +370,10 @@ export declare class AIAgent<I extends Message = any, O extends Message = any> e
         metadataEnd: string;
         parse: (raw: string) => object;
     };
-    compact?: CompactConfig;
+    /**
+     * Agent session configuration
+     */
+    session?: Partial<Omit<import("../prompt/agent-session.js").AgentSessionOptions, "sessionId" | "userId" | "agentId" | "afs">>;
     get inputSchema(): ZodType<I>;
     /**
      * Process an input message and generate a response

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

package/lib/dts/prompt/compact/session-memory-extractor.d.ts

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