@aigne/core 1.72.0-beta.16 → 1.72.0-beta.18

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.72.0-beta.18](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.72.0-beta.17...core-v1.72.0-beta.18) (2026-01-13)
+
+
+### Bug Fixes
+
+* bump deps to latest and fix build error ([#897](https://github.com/AIGNE-io/aigne-framework/issues/897)) ([4059e79](https://github.com/AIGNE-io/aigne-framework/commit/4059e790ae63b9e4ebd66487665014b0cd7ce6ec))
+* **core:** make async memory updates non-blocking ([#900](https://github.com/AIGNE-io/aigne-framework/issues/900)) ([314f2c3](https://github.com/AIGNE-io/aigne-framework/commit/314f2c35d8baa88b600cc4de3f5983fef03a804c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/observability-api bumped to 0.11.14-beta.3
+
+## [1.72.0-beta.17](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.72.0-beta.16...core-v1.72.0-beta.17) (2026-01-12)
+
+
+### Bug Fixes
+
+* **core:** optimize session compaction to reduce compression frequency ([#894](https://github.com/AIGNE-io/aigne-framework/issues/894)) ([bed53dc](https://github.com/AIGNE-io/aigne-framework/commit/bed53dc0311c69acd2c257fe93416d10ac1120e1))
+
 ## [1.72.0-beta.16](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.72.0-beta.15...core-v1.72.0-beta.16) (2026-01-12)
 
 

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

@@ -470,9 +470,8 @@ class AIAgent extends agent_js_1.Agent {
                 else {
                     yield { delta: { text: { [outputKey]: "\n\n" } } };
                 }
-                const message = { role: "agent", toolCalls };
-                yield { progress: { event: "message", message } };
-                await session.appendCurrentMessages(message, options);
+                const toolCallMessage = { role: "agent", toolCalls };
+                yield { progress: { event: "message", message: toolCallMessage } };
                 const executedToolCalls = [];
                 let error;
                 const queue = fastq.promise(async ({ tool, call }) => {
@@ -503,6 +502,7 @@ class AIAgent extends agent_js_1.Agent {
                 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, tool, output } of executedToolCalls) {
@@ -514,11 +514,12 @@ class AIAgent extends agent_js_1.Agent {
                             content: [{ type: "text", text, isAgentSkill }],
                         };
                         yield { progress: { event: "message", message: message } };
-                        await session.appendCurrentMessages(message, options);
+                        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;
                 }
             }

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

@@ -80,7 +80,9 @@ export declare class AgentSession {
     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;
     /**
@@ -89,6 +91,14 @@ export declare class AgentSession {
      */
     private splitIntoBatches;
     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;
@@ -148,6 +158,6 @@ export declare class AgentSession {
     private initializeDefaultUserMemoryExtractor;
     private get maxTokens();
     private get keepRecentRatio();
-    private get keepTokenBudget();
+    private get keepRecentTokens();
     private get singleMessageLimit();
 }

package/lib/cjs/prompt/agent-session.js

@@ -41,6 +41,7 @@ const afs_history_1 = require("@aigne/afs-history");
 const uuid_1 = require("@aigne/uuid");
 const ufo_1 = require("ufo");
 const yaml_1 = require("yaml");
+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 types_js_1 = require("./compact/types.js");
@@ -290,7 +291,9 @@ ${"```"}
         this.compactionPromise = this.doCompact(options).finally(() => {
             this.compactionPromise = undefined;
         });
-        return this.compactionPromise;
+        const isAsync = this.compactConfig.async ?? types_js_1.DEFAULT_COMPACT_ASYNC;
+        if (!isAsync)
+            await this.compactionPromise;
     }
     /**
      * Internal method that performs the actual compaction
@@ -304,20 +307,18 @@ ${"```"}
         if (historyEntries.length === 0)
             return;
         const maxTokens = this.maxTokens;
-        let keepTokenBudget = this.keepTokenBudget;
-        // Calculate tokens for system messages
-        const systemTokens = (this.runtimeState.systemMessages ?? []).reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            return sum + (0, token_estimator_js_1.estimateTokens)(content);
-        }, 0);
-        // Calculate tokens for current entry messages
-        const currentTokens = (this.runtimeState.currentEntry?.messages ?? []).reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            return sum + (0, token_estimator_js_1.estimateTokens)(content);
-        }, 0);
-        // Subtract system and current tokens from budget
-        // This ensures total tokens (system + current + kept history) stays within ratio budget
-        keepTokenBudget = Math.max(0, keepTokenBudget - systemTokens - currentTokens);
+        // Target to keep only 50% of keepRecentTokens to leave buffer room
+        // This avoids triggering compression again shortly after compaction
+        // Similar to compactCurrentEntry, we compress more aggressively to leave headroom
+        //
+        // Note: We don't subtract systemTokens or currentEntry tokens because:
+        // 1. keepRecentTokens is already a relative ratio (e.g., 50% of maxTokens)
+        // 2. systemTokens overhead is typically small (~1-2k, ~1-2% of maxTokens)
+        // 3. currentEntry is still being constructed (not yet added to history)
+        // 4. In tool use scenarios, currentEntry can be very large (many tool calls)
+        // 5. Subtracting them would complicate logic without significant benefit
+        // 6. Total token limit is enforced by maybeAutoCompact trigger condition
+        const keepRecentTokens = this.keepRecentTokens * 0.5;
         // Find split point by iterating backwards from most recent entry
         // The split point divides history into: [compact] | [keep]
         let splitIndex = historyEntries.length; // Default: keep all (no compaction)
@@ -328,7 +329,7 @@ ${"```"}
                 continue;
             const entryTokens = this.estimateMessagesTokens(entry.content?.messages ?? []);
             // Check if adding this entry would exceed token budget
-            if (accumulatedTokens + entryTokens > keepTokenBudget) {
+            if (accumulatedTokens + entryTokens > keepRecentTokens) {
                 // Would exceed budget, split here (this entry and earlier ones will be compacted)
                 splitIndex = i + 1;
                 break;
@@ -399,22 +400,21 @@ ${"```"}
         const uncompressedMessages = currentEntry.messages.slice(alreadyCompressedCount);
         if (uncompressedMessages.length === 0)
             return;
-        const keepTokenBudget = this.keepTokenBudget;
-        const singleMessageLimit = this.singleMessageLimit;
+        // Target to keep only 50% of keepTokenBudget to leave buffer room
+        // This avoids frequent small-batch compressions in tool use scenarios
+        const keepTokenBudget = this.keepRecentTokens * 0.5;
         let splitIndex = uncompressedMessages.length;
         let accumulatedTokens = 0;
         for (let i = uncompressedMessages.length - 1; i >= 0; i--) {
             const msg = uncompressedMessages[i];
             if (!msg)
                 continue;
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            const msgTokens = (0, token_estimator_js_1.estimateTokens)(content);
-            const effectiveTokens = msgTokens > singleMessageLimit ? singleMessageLimit : msgTokens;
-            if (accumulatedTokens + effectiveTokens > keepTokenBudget) {
+            const msgTokens = this.estimateMessagesTokens([msg]);
+            if (accumulatedTokens + msgTokens > keepTokenBudget) {
                 splitIndex = i + 1;
                 break;
             }
-            accumulatedTokens += effectiveTokens;
+            accumulatedTokens += msgTokens;
             splitIndex = i;
         }
         const keptMessages = uncompressedMessages.slice(splitIndex);
@@ -463,8 +463,8 @@ ${"```"}
             return;
         const compressedCount = this.runtimeState.currentEntryCompact?.compressedCount ?? 0;
         const uncompressedMessages = currentEntry.messages.slice(compressedCount);
-        const threshold = this.keepTokenBudget;
-        const currentTokens = this.estimateMessagesTokens(uncompressedMessages, this.singleMessageLimit);
+        const threshold = this.keepRecentTokens;
+        const currentTokens = this.estimateMessagesTokens(uncompressedMessages);
         if (currentTokens > threshold) {
             await this.compactCurrentEntry(options);
         }
@@ -472,8 +472,6 @@ ${"```"}
     async maybeAutoCompact(options) {
         if (this.compactionPromise)
             await this.compactionPromise;
-        if (!this.compactConfig)
-            return;
         const mode = this.compactConfig.mode ?? types_js_1.DEFAULT_COMPACT_MODE;
         if (mode === "disabled")
             return;
@@ -484,24 +482,48 @@ ${"```"}
         const messages = await this.getMessages();
         const currentTokens = this.estimateMessagesTokens(messages);
         if (currentTokens >= maxTokens) {
-            this.compact(options);
-            const isAsync = this.compactConfig.async ?? types_js_1.DEFAULT_COMPACT_ASYNC;
-            if (!isAsync)
-                await this.compactionPromise;
+            await this.compact(options);
         }
     }
     /**
-     * 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
      */
-    estimateMessagesTokens(messages, singleMessageLimit) {
-        return messages.reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            const tokens = (0, token_estimator_js_1.estimateTokens)(content);
-            if (singleMessageLimit && tokens > singleMessageLimit) {
-                return sum + singleMessageLimit;
+    estimateMessagesTokens(messages, singleMessageLimit = this.singleMessageLimit) {
+        let totalTokens = 0;
+        for (const msg of messages) {
+            // 1. Estimate content tokens
+            if (typeof msg.content === "string") {
+                const textTokens = (0, token_estimator_js_1.estimateTokens)(msg.content);
+                const effectiveTokens = textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+                totalTokens += effectiveTokens;
             }
-            return sum + tokens;
-        }, 0);
+            else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === "text" && typeof block.text === "string") {
+                        // Text tokens (can be truncated) - apply limit to each block individually
+                        const textTokens = (0, token_estimator_js_1.estimateTokens)(block.text);
+                        const effectiveTokens = textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+                        totalTokens += effectiveTokens;
+                    }
+                    else {
+                        // Non-text blocks - always counted in full
+                        totalTokens += 1000;
+                    }
+                }
+            }
+            // 2. Estimate tool calls tokens (cannot be truncated)
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                for (const toolCall of msg.toolCalls) {
+                    // Function name + arguments + overhead
+                    totalTokens += (0, token_estimator_js_1.estimateTokens)(toolCall.function.name);
+                    totalTokens += (0, token_estimator_js_1.estimateTokens)((0, yaml_1.stringify)(toolCall.function.arguments).replace(/\s+/g, " "));
+                    totalTokens += 10; // Structure overhead
+                }
+            }
+        }
+        return totalTokens;
     }
     /**
      * Split entries into batches based on token limit
@@ -538,22 +560,54 @@ ${"```"}
         this.runtimeState.currentEntry.messages.push(...[messages].flat());
         await this.maybeCompactCurrentEntry(options);
     }
-    truncateLargeMessage(msg) {
-        const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-        const tokens = (0, token_estimator_js_1.estimateTokens)(content);
-        const singleMessageLimit = this.singleMessageLimit;
-        if (tokens <= singleMessageLimit)
-            return msg;
-        const keepRatio = (singleMessageLimit / tokens) * 0.9;
-        const keepLength = Math.floor(content.length * keepRatio);
+    /**
+     * 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
+     */
+    truncateText(text, currentTokens, targetTokens) {
+        if (currentTokens <= targetTokens)
+            return text;
+        const keepRatio = (targetTokens / currentTokens) * 0.9;
+        const keepLength = Math.floor(text.length * keepRatio);
         const headLength = Math.floor(keepLength * 0.7);
         const tailLength = Math.floor(keepLength * 0.3);
-        const truncated = content.slice(0, headLength) +
-            `\n\n[... Content too large, truncated ${tokens - singleMessageLimit} tokens ...]\n\n` +
-            content.slice(-tailLength);
+        return (text.slice(0, headLength) +
+            `\n\n[... truncated ${currentTokens - targetTokens} tokens ...]\n\n` +
+            text.slice(-tailLength));
+    }
+    truncateLargeMessage(msg) {
+        const singleMessageLimit = this.singleMessageLimit;
+        // Handle string content
         if (typeof msg.content === "string") {
+            const tokens = (0, token_estimator_js_1.estimateTokens)(msg.content);
+            if (tokens <= singleMessageLimit)
+                return msg;
+            const truncated = this.truncateText(msg.content, tokens, singleMessageLimit);
             return { ...msg, content: truncated };
         }
+        // Handle array content (UnionContent[])
+        if (Array.isArray(msg.content)) {
+            // Truncate each text block individually if it exceeds the limit
+            const truncatedContent = msg.content.map((block) => {
+                // Keep non-text blocks unchanged
+                if (block.type !== "text" || typeof block.text !== "string") {
+                    return block;
+                }
+                // Check if this text block needs truncation
+                const blockTokens = (0, token_estimator_js_1.estimateTokens)(block.text);
+                if (blockTokens <= singleMessageLimit) {
+                    return block;
+                }
+                // Truncate this text block independently
+                const truncatedText = this.truncateText(block.text, blockTokens, singleMessageLimit);
+                return { ...block, text: truncatedText };
+            });
+            return { ...msg, content: truncatedContent };
+        }
+        // Unknown content type, return as-is
         return msg;
     }
     async ensureInitialized() {
@@ -671,53 +725,46 @@ ${"```"}
      */
     async updateSessionMemory(options) {
         await this.ensureInitialized();
-        // If session memory update is already in progress, wait for it to complete
-        if (this.sessionMemoryUpdatePromise) {
-            return this.sessionMemoryUpdatePromise;
-        }
-        // Start new session memory update task
-        this.sessionMemoryUpdatePromise = this.doUpdateSessionMemory(options).finally(() => {
+        this.sessionMemoryUpdatePromise ??= this.doUpdateSessionMemory(options)
+            .then(() => {
+            // After session memory update succeeds, potentially trigger user memory consolidation
+            this.maybeAutoUpdateUserMemory(options).catch((err) => {
+                logger_js_1.logger.error("User memory update failed:", err);
+            });
+        })
+            .finally(() => {
             this.sessionMemoryUpdatePromise = undefined;
-            // After session memory update completes, potentially trigger user memory consolidation
-            this.maybeAutoUpdateUserMemory(options);
         });
         return this.sessionMemoryUpdatePromise;
     }
     async maybeAutoUpdateSessionMemory(options) {
-        if (this.sessionMemoryUpdatePromise)
-            await this.sessionMemoryUpdatePromise;
         // Check if memory extraction is enabled (requires AFS history module)
         if (!this.isMemoryEnabled)
             return;
-        if (!this.sessionMemoryConfig)
-            return;
         // Check if mode is disabled
         const mode = this.sessionMemoryConfig.mode ?? types_js_1.DEFAULT_SESSION_MEMORY_MODE;
         if (mode === "disabled")
             return;
         // Trigger session memory update
-        this.updateSessionMemory(options);
+        this.updateSessionMemory(options).catch((err) => {
+            logger_js_1.logger.error("Session memory update failed:", err);
+        });
         const isAsync = this.sessionMemoryConfig.async ?? types_js_1.DEFAULT_SESSION_MEMORY_ASYNC;
         if (!isAsync)
             await this.sessionMemoryUpdatePromise;
     }
     async maybeAutoUpdateUserMemory(options) {
-        if (this.userMemoryUpdatePromise)
-            await this.userMemoryUpdatePromise;
         // Check if memory extraction is enabled (requires AFS history module)
-        if (!this.isMemoryEnabled)
-            return;
-        if (!this.userMemoryConfig || !this.userId)
+        if (!this.isMemoryEnabled || !this.userId)
             return;
         // Check if mode is disabled
         const mode = this.userMemoryConfig.mode ?? types_js_1.DEFAULT_USER_MEMORY_MODE;
         if (mode === "disabled")
             return;
-        // Wait for session memory update to complete first
-        if (this.sessionMemoryUpdatePromise)
-            await this.sessionMemoryUpdatePromise;
         // Trigger user memory consolidation
-        this.updateUserMemory(options);
+        this.updateUserMemory(options).catch((err) => {
+            logger_js_1.logger.error("User memory update failed:", err);
+        });
         const isAsync = this.userMemoryConfig.async ?? types_js_1.DEFAULT_USER_MEMORY_ASYNC;
         if (!isAsync)
             await this.userMemoryUpdatePromise;
@@ -812,12 +859,8 @@ ${"```"}
      */
     async updateUserMemory(options) {
         await this.ensureInitialized();
-        // If user memory update is already in progress, wait for it to complete
-        if (this.userMemoryUpdatePromise) {
-            return this.userMemoryUpdatePromise;
-        }
         // Start new user memory update task
-        this.userMemoryUpdatePromise = this.doUpdateUserMemory(options).finally(() => {
+        this.userMemoryUpdatePromise ??= this.doUpdateUserMemory(options).finally(() => {
             this.userMemoryUpdatePromise = undefined;
         });
         return this.userMemoryUpdatePromise;
@@ -955,11 +998,11 @@ ${"```"}
     get keepRecentRatio() {
         return this.compactConfig?.keepRecentRatio ?? types_js_1.DEFAULT_KEEP_RECENT_RATIO;
     }
-    get keepTokenBudget() {
+    get keepRecentTokens() {
         return Math.floor(this.maxTokens * this.keepRecentRatio);
     }
     get singleMessageLimit() {
-        return this.keepTokenBudget * 0.5;
+        return this.keepRecentTokens * 0.5;
     }
 }
 exports.AgentSession = AgentSession;

package/lib/cjs/prompt/compact/compactor.js

@@ -41,6 +41,7 @@ class AISessionCompactor extends ai_agent_js_1.AIAgent {
                 summary: zod_1.z.string().describe("A comprehensive summary of the conversation history"),
             }),
             instructions: COMPACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...(0, type_utils_js_1.omitBy)(options ?? {}, (v) => (0, type_utils_js_1.isNil)(v)),
             session: {
                 mode: "disabled",

package/lib/cjs/prompt/compact/session-memory-extractor.js

@@ -132,6 +132,7 @@ class AISessionMemoryExtractor extends ai_agent_js_1.AIAgent {
                 removeFacts: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string()).describe("Labels of facts to remove from memory")),
             }),
             instructions: EXTRACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...(0, type_utils_js_1.omitBy)(options ?? {}, (v) => (0, type_utils_js_1.isNil)(v)),
             session: {
                 mode: "disabled",

package/lib/cjs/prompt/compact/user-memory-extractor.js

@@ -113,6 +113,7 @@ class AIUserMemoryExtractor extends ai_agent_js_1.AIAgent {
                 removeFacts: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string()).describe("Labels of facts to remove from user memory")),
             }),
             instructions: EXTRACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...(0, type_utils_js_1.omitBy)(options ?? {}, (v) => (0, type_utils_js_1.isNil)(v)),
             session: {
                 mode: "disabled",

package/lib/cjs/prompt/prompt-builder.js

@@ -40,10 +40,10 @@ class PromptBuilder {
                     content = i.content.text;
                 else if (i.content.type === "resource") {
                     const { resource } = i.content;
-                    if (typeof resource.text === "string") {
+                    if ("text" in resource && typeof resource.text === "string") {
                         content = resource.text;
                     }
-                    else if (typeof resource.blob === "string") {
+                    else if ("blob" in resource && typeof resource.blob === "string") {
                         content = [{ type: "url", url: resource.blob }];
                     }
                 }

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

@@ -8,6 +8,7 @@ export interface Skill {
 }
 export declare function loadSkill(path: string): Promise<Skill>;
 export declare function loadSkills(paths: string[]): Promise<Skill[]>;
+export declare function discoverSkillsFromAFS(afs: AFS): Promise<Skill[]>;
 export declare function loadAgentSkillFromAFS({ afs, }: {
     afs: AFS;
 }): Promise<AgentSkill | undefined>;

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (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"));
@@ -31,7 +32,7 @@ async function loadSkills(paths) {
     }
     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" &&
@@ -39,7 +40,7 @@ async function loadAgentSkillFromAFS({ afs, }) {
         "agentSkills" in m.options &&
         m.options.agentSkills === true);
     if (!filtered.length)
-        return;
+        return [];
     const skills = [];
     for (const module of filtered) {
         const data = (await afs
@@ -56,6 +57,10 @@ async function loadAgentSkillFromAFS({ afs, }) {
             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/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/dts/prompt/agent-session.d.ts

@@ -80,7 +80,9 @@ export declare class AgentSession {
     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;
     /**
@@ -89,6 +91,14 @@ export declare class AgentSession {
      */
     private splitIntoBatches;
     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;
@@ -148,6 +158,6 @@ export declare class AgentSession {
     private initializeDefaultUserMemoryExtractor;
     private get maxTokens();
     private get keepRecentRatio();
-    private get keepTokenBudget();
+    private get keepRecentTokens();
     private get singleMessageLimit();
 }

package/lib/dts/prompt/skills/afs/agent-skill/skill-loader.d.ts

@@ -8,6 +8,7 @@ export interface Skill {
 }
 export declare function loadSkill(path: string): Promise<Skill>;
 export declare function loadSkills(paths: string[]): Promise<Skill[]>;
+export declare function discoverSkillsFromAFS(afs: AFS): Promise<Skill[]>;
 export declare function loadAgentSkillFromAFS({ afs, }: {
     afs: AFS;
 }): Promise<AgentSkill | undefined>;

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

@@ -434,9 +434,8 @@ export class AIAgent extends Agent {
                 else {
                     yield { delta: { text: { [outputKey]: "\n\n" } } };
                 }
-                const message = { role: "agent", toolCalls };
-                yield { progress: { event: "message", message } };
-                await session.appendCurrentMessages(message, options);
+                const toolCallMessage = { role: "agent", toolCalls };
+                yield { progress: { event: "message", message: toolCallMessage } };
                 const executedToolCalls = [];
                 let error;
                 const queue = fastq.promise(async ({ tool, call }) => {
@@ -467,6 +466,7 @@ export class AIAgent extends Agent {
                 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, tool, output } of executedToolCalls) {
@@ -478,11 +478,12 @@ export class AIAgent extends Agent {
                             content: [{ type: "text", text, isAgentSkill }],
                         };
                         yield { progress: { event: "message", message: message } };
-                        await session.appendCurrentMessages(message, options);
+                        toolResultMessages.push(message);
                     }
                     const transferOutput = executedToolCalls.find((i) => isTransferAgentOutput(i.output))?.output;
                     if (transferOutput)
                         return transferOutput;
+                    await session.appendCurrentMessages([toolCallMessage, ...toolResultMessages], options);
                     continue;
                 }
             }

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

@@ -80,7 +80,9 @@ export declare class AgentSession {
     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;
     /**
@@ -89,6 +91,14 @@ export declare class AgentSession {
      */
     private splitIntoBatches;
     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;
@@ -148,6 +158,6 @@ export declare class AgentSession {
     private initializeDefaultUserMemoryExtractor;
     private get maxTokens();
     private get keepRecentRatio();
-    private get keepTokenBudget();
+    private get keepRecentTokens();
     private get singleMessageLimit();
 }

package/lib/esm/prompt/agent-session.js

@@ -2,6 +2,7 @@ import { AFSHistory } from "@aigne/afs-history";
 import { v7 } from "@aigne/uuid";
 import { joinURL } from "ufo";
 import { stringify } from "yaml";
+import { logger } from "../utils/logger.js";
 import { estimateTokens } from "../utils/token-estimator.js";
 import { isNonNullable } from "../utils/type-utils.js";
 import { DEFAULT_COMPACT_ASYNC, DEFAULT_COMPACT_MODE, DEFAULT_KEEP_RECENT_RATIO, DEFAULT_MAX_TOKENS, DEFAULT_MEMORY_QUERY_LIMIT, DEFAULT_MEMORY_RATIO, DEFAULT_SESSION_MEMORY_ASYNC, DEFAULT_SESSION_MEMORY_MODE, DEFAULT_SESSION_MODE, DEFAULT_USER_MEMORY_ASYNC, DEFAULT_USER_MEMORY_MODE, } from "./compact/types.js";
@@ -251,7 +252,9 @@ ${"```"}
         this.compactionPromise = this.doCompact(options).finally(() => {
             this.compactionPromise = undefined;
         });
-        return this.compactionPromise;
+        const isAsync = this.compactConfig.async ?? DEFAULT_COMPACT_ASYNC;
+        if (!isAsync)
+            await this.compactionPromise;
     }
     /**
      * Internal method that performs the actual compaction
@@ -265,20 +268,18 @@ ${"```"}
         if (historyEntries.length === 0)
             return;
         const maxTokens = this.maxTokens;
-        let keepTokenBudget = this.keepTokenBudget;
-        // Calculate tokens for system messages
-        const systemTokens = (this.runtimeState.systemMessages ?? []).reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            return sum + estimateTokens(content);
-        }, 0);
-        // Calculate tokens for current entry messages
-        const currentTokens = (this.runtimeState.currentEntry?.messages ?? []).reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            return sum + estimateTokens(content);
-        }, 0);
-        // Subtract system and current tokens from budget
-        // This ensures total tokens (system + current + kept history) stays within ratio budget
-        keepTokenBudget = Math.max(0, keepTokenBudget - systemTokens - currentTokens);
+        // Target to keep only 50% of keepRecentTokens to leave buffer room
+        // This avoids triggering compression again shortly after compaction
+        // Similar to compactCurrentEntry, we compress more aggressively to leave headroom
+        //
+        // Note: We don't subtract systemTokens or currentEntry tokens because:
+        // 1. keepRecentTokens is already a relative ratio (e.g., 50% of maxTokens)
+        // 2. systemTokens overhead is typically small (~1-2k, ~1-2% of maxTokens)
+        // 3. currentEntry is still being constructed (not yet added to history)
+        // 4. In tool use scenarios, currentEntry can be very large (many tool calls)
+        // 5. Subtracting them would complicate logic without significant benefit
+        // 6. Total token limit is enforced by maybeAutoCompact trigger condition
+        const keepRecentTokens = this.keepRecentTokens * 0.5;
         // Find split point by iterating backwards from most recent entry
         // The split point divides history into: [compact] | [keep]
         let splitIndex = historyEntries.length; // Default: keep all (no compaction)
@@ -289,7 +290,7 @@ ${"```"}
                 continue;
             const entryTokens = this.estimateMessagesTokens(entry.content?.messages ?? []);
             // Check if adding this entry would exceed token budget
-            if (accumulatedTokens + entryTokens > keepTokenBudget) {
+            if (accumulatedTokens + entryTokens > keepRecentTokens) {
                 // Would exceed budget, split here (this entry and earlier ones will be compacted)
                 splitIndex = i + 1;
                 break;
@@ -360,22 +361,21 @@ ${"```"}
         const uncompressedMessages = currentEntry.messages.slice(alreadyCompressedCount);
         if (uncompressedMessages.length === 0)
             return;
-        const keepTokenBudget = this.keepTokenBudget;
-        const singleMessageLimit = this.singleMessageLimit;
+        // Target to keep only 50% of keepTokenBudget to leave buffer room
+        // This avoids frequent small-batch compressions in tool use scenarios
+        const keepTokenBudget = this.keepRecentTokens * 0.5;
         let splitIndex = uncompressedMessages.length;
         let accumulatedTokens = 0;
         for (let i = uncompressedMessages.length - 1; i >= 0; i--) {
             const msg = uncompressedMessages[i];
             if (!msg)
                 continue;
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            const msgTokens = estimateTokens(content);
-            const effectiveTokens = msgTokens > singleMessageLimit ? singleMessageLimit : msgTokens;
-            if (accumulatedTokens + effectiveTokens > keepTokenBudget) {
+            const msgTokens = this.estimateMessagesTokens([msg]);
+            if (accumulatedTokens + msgTokens > keepTokenBudget) {
                 splitIndex = i + 1;
                 break;
             }
-            accumulatedTokens += effectiveTokens;
+            accumulatedTokens += msgTokens;
             splitIndex = i;
         }
         const keptMessages = uncompressedMessages.slice(splitIndex);
@@ -424,8 +424,8 @@ ${"```"}
             return;
         const compressedCount = this.runtimeState.currentEntryCompact?.compressedCount ?? 0;
         const uncompressedMessages = currentEntry.messages.slice(compressedCount);
-        const threshold = this.keepTokenBudget;
-        const currentTokens = this.estimateMessagesTokens(uncompressedMessages, this.singleMessageLimit);
+        const threshold = this.keepRecentTokens;
+        const currentTokens = this.estimateMessagesTokens(uncompressedMessages);
         if (currentTokens > threshold) {
             await this.compactCurrentEntry(options);
         }
@@ -433,8 +433,6 @@ ${"```"}
     async maybeAutoCompact(options) {
         if (this.compactionPromise)
             await this.compactionPromise;
-        if (!this.compactConfig)
-            return;
         const mode = this.compactConfig.mode ?? DEFAULT_COMPACT_MODE;
         if (mode === "disabled")
             return;
@@ -445,24 +443,48 @@ ${"```"}
         const messages = await this.getMessages();
         const currentTokens = this.estimateMessagesTokens(messages);
         if (currentTokens >= maxTokens) {
-            this.compact(options);
-            const isAsync = this.compactConfig.async ?? DEFAULT_COMPACT_ASYNC;
-            if (!isAsync)
-                await this.compactionPromise;
+            await this.compact(options);
         }
     }
     /**
-     * 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
      */
-    estimateMessagesTokens(messages, singleMessageLimit) {
-        return messages.reduce((sum, msg) => {
-            const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
-            const tokens = estimateTokens(content);
-            if (singleMessageLimit && tokens > singleMessageLimit) {
-                return sum + singleMessageLimit;
+    estimateMessagesTokens(messages, singleMessageLimit = this.singleMessageLimit) {
+        let totalTokens = 0;
+        for (const msg of messages) {
+            // 1. Estimate content tokens
+            if (typeof msg.content === "string") {
+                const textTokens = estimateTokens(msg.content);
+                const effectiveTokens = textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+                totalTokens += effectiveTokens;
             }
-            return sum + tokens;
-        }, 0);
+            else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === "text" && typeof block.text === "string") {
+                        // Text tokens (can be truncated) - apply limit to each block individually
+                        const textTokens = estimateTokens(block.text);
+                        const effectiveTokens = textTokens > singleMessageLimit ? singleMessageLimit : textTokens;
+                        totalTokens += effectiveTokens;
+                    }
+                    else {
+                        // Non-text blocks - always counted in full
+                        totalTokens += 1000;
+                    }
+                }
+            }
+            // 2. Estimate tool calls tokens (cannot be truncated)
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                for (const toolCall of msg.toolCalls) {
+                    // Function name + arguments + overhead
+                    totalTokens += estimateTokens(toolCall.function.name);
+                    totalTokens += estimateTokens(stringify(toolCall.function.arguments).replace(/\s+/g, " "));
+                    totalTokens += 10; // Structure overhead
+                }
+            }
+        }
+        return totalTokens;
     }
     /**
      * Split entries into batches based on token limit
@@ -499,22 +521,54 @@ ${"```"}
         this.runtimeState.currentEntry.messages.push(...[messages].flat());
         await this.maybeCompactCurrentEntry(options);
     }
-    truncateLargeMessage(msg) {
-        const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-        const tokens = estimateTokens(content);
-        const singleMessageLimit = this.singleMessageLimit;
-        if (tokens <= singleMessageLimit)
-            return msg;
-        const keepRatio = (singleMessageLimit / tokens) * 0.9;
-        const keepLength = Math.floor(content.length * keepRatio);
+    /**
+     * 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
+     */
+    truncateText(text, currentTokens, targetTokens) {
+        if (currentTokens <= targetTokens)
+            return text;
+        const keepRatio = (targetTokens / currentTokens) * 0.9;
+        const keepLength = Math.floor(text.length * keepRatio);
         const headLength = Math.floor(keepLength * 0.7);
         const tailLength = Math.floor(keepLength * 0.3);
-        const truncated = content.slice(0, headLength) +
-            `\n\n[... Content too large, truncated ${tokens - singleMessageLimit} tokens ...]\n\n` +
-            content.slice(-tailLength);
+        return (text.slice(0, headLength) +
+            `\n\n[... truncated ${currentTokens - targetTokens} tokens ...]\n\n` +
+            text.slice(-tailLength));
+    }
+    truncateLargeMessage(msg) {
+        const singleMessageLimit = this.singleMessageLimit;
+        // Handle string content
         if (typeof msg.content === "string") {
+            const tokens = estimateTokens(msg.content);
+            if (tokens <= singleMessageLimit)
+                return msg;
+            const truncated = this.truncateText(msg.content, tokens, singleMessageLimit);
             return { ...msg, content: truncated };
         }
+        // Handle array content (UnionContent[])
+        if (Array.isArray(msg.content)) {
+            // Truncate each text block individually if it exceeds the limit
+            const truncatedContent = msg.content.map((block) => {
+                // Keep non-text blocks unchanged
+                if (block.type !== "text" || typeof block.text !== "string") {
+                    return block;
+                }
+                // Check if this text block needs truncation
+                const blockTokens = estimateTokens(block.text);
+                if (blockTokens <= singleMessageLimit) {
+                    return block;
+                }
+                // Truncate this text block independently
+                const truncatedText = this.truncateText(block.text, blockTokens, singleMessageLimit);
+                return { ...block, text: truncatedText };
+            });
+            return { ...msg, content: truncatedContent };
+        }
+        // Unknown content type, return as-is
         return msg;
     }
     async ensureInitialized() {
@@ -632,53 +686,46 @@ ${"```"}
      */
     async updateSessionMemory(options) {
         await this.ensureInitialized();
-        // If session memory update is already in progress, wait for it to complete
-        if (this.sessionMemoryUpdatePromise) {
-            return this.sessionMemoryUpdatePromise;
-        }
-        // Start new session memory update task
-        this.sessionMemoryUpdatePromise = this.doUpdateSessionMemory(options).finally(() => {
+        this.sessionMemoryUpdatePromise ??= this.doUpdateSessionMemory(options)
+            .then(() => {
+            // After session memory update succeeds, potentially trigger user memory consolidation
+            this.maybeAutoUpdateUserMemory(options).catch((err) => {
+                logger.error("User memory update failed:", err);
+            });
+        })
+            .finally(() => {
             this.sessionMemoryUpdatePromise = undefined;
-            // After session memory update completes, potentially trigger user memory consolidation
-            this.maybeAutoUpdateUserMemory(options);
         });
         return this.sessionMemoryUpdatePromise;
     }
     async maybeAutoUpdateSessionMemory(options) {
-        if (this.sessionMemoryUpdatePromise)
-            await this.sessionMemoryUpdatePromise;
         // Check if memory extraction is enabled (requires AFS history module)
         if (!this.isMemoryEnabled)
             return;
-        if (!this.sessionMemoryConfig)
-            return;
         // Check if mode is disabled
         const mode = this.sessionMemoryConfig.mode ?? DEFAULT_SESSION_MEMORY_MODE;
         if (mode === "disabled")
             return;
         // Trigger session memory update
-        this.updateSessionMemory(options);
+        this.updateSessionMemory(options).catch((err) => {
+            logger.error("Session memory update failed:", err);
+        });
         const isAsync = this.sessionMemoryConfig.async ?? DEFAULT_SESSION_MEMORY_ASYNC;
         if (!isAsync)
             await this.sessionMemoryUpdatePromise;
     }
     async maybeAutoUpdateUserMemory(options) {
-        if (this.userMemoryUpdatePromise)
-            await this.userMemoryUpdatePromise;
         // Check if memory extraction is enabled (requires AFS history module)
-        if (!this.isMemoryEnabled)
-            return;
-        if (!this.userMemoryConfig || !this.userId)
+        if (!this.isMemoryEnabled || !this.userId)
             return;
         // Check if mode is disabled
         const mode = this.userMemoryConfig.mode ?? DEFAULT_USER_MEMORY_MODE;
         if (mode === "disabled")
             return;
-        // Wait for session memory update to complete first
-        if (this.sessionMemoryUpdatePromise)
-            await this.sessionMemoryUpdatePromise;
         // Trigger user memory consolidation
-        this.updateUserMemory(options);
+        this.updateUserMemory(options).catch((err) => {
+            logger.error("User memory update failed:", err);
+        });
         const isAsync = this.userMemoryConfig.async ?? DEFAULT_USER_MEMORY_ASYNC;
         if (!isAsync)
             await this.userMemoryUpdatePromise;
@@ -773,12 +820,8 @@ ${"```"}
      */
     async updateUserMemory(options) {
         await this.ensureInitialized();
-        // If user memory update is already in progress, wait for it to complete
-        if (this.userMemoryUpdatePromise) {
-            return this.userMemoryUpdatePromise;
-        }
         // Start new user memory update task
-        this.userMemoryUpdatePromise = this.doUpdateUserMemory(options).finally(() => {
+        this.userMemoryUpdatePromise ??= this.doUpdateUserMemory(options).finally(() => {
             this.userMemoryUpdatePromise = undefined;
         });
         return this.userMemoryUpdatePromise;
@@ -916,10 +959,10 @@ ${"```"}
     get keepRecentRatio() {
         return this.compactConfig?.keepRecentRatio ?? DEFAULT_KEEP_RECENT_RATIO;
     }
-    get keepTokenBudget() {
+    get keepRecentTokens() {
         return Math.floor(this.maxTokens * this.keepRecentRatio);
     }
     get singleMessageLimit() {
-        return this.keepTokenBudget * 0.5;
+        return this.keepRecentTokens * 0.5;
     }
 }

package/lib/esm/prompt/compact/compactor.js

@@ -38,6 +38,7 @@ export class AISessionCompactor extends AIAgent {
                 summary: z.string().describe("A comprehensive summary of the conversation history"),
             }),
             instructions: COMPACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...omitBy(options ?? {}, (v) => isNil(v)),
             session: {
                 mode: "disabled",

package/lib/esm/prompt/compact/session-memory-extractor.js

@@ -129,6 +129,7 @@ export class AISessionMemoryExtractor extends AIAgent {
                 removeFacts: optional(z.array(z.string()).describe("Labels of facts to remove from memory")),
             }),
             instructions: EXTRACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...omitBy(options ?? {}, (v) => isNil(v)),
             session: {
                 mode: "disabled",

package/lib/esm/prompt/compact/user-memory-extractor.js

@@ -110,6 +110,7 @@ export class AIUserMemoryExtractor extends AIAgent {
                 removeFacts: optional(z.array(z.string()).describe("Labels of facts to remove from user memory")),
             }),
             instructions: EXTRACTOR_INSTRUCTIONS,
+            taskRenderMode: "hide",
             ...omitBy(options ?? {}, (v) => isNil(v)),
             session: {
                 mode: "disabled",

package/lib/esm/prompt/prompt-builder.js

@@ -37,10 +37,10 @@ export class PromptBuilder {
                     content = i.content.text;
                 else if (i.content.type === "resource") {
                     const { resource } = i.content;
-                    if (typeof resource.text === "string") {
+                    if ("text" in resource && typeof resource.text === "string") {
                         content = resource.text;
                     }
-                    else if (typeof resource.blob === "string") {
+                    else if ("blob" in resource && typeof resource.blob === "string") {
                         content = [{ type: "url", url: resource.blob }];
                     }
                 }

package/lib/esm/prompt/skills/afs/agent-skill/skill-loader.d.ts

@@ -8,6 +8,7 @@ export interface Skill {
 }
 export declare function loadSkill(path: string): Promise<Skill>;
 export declare function loadSkills(paths: string[]): Promise<Skill[]>;
+export declare function discoverSkillsFromAFS(afs: AFS): Promise<Skill[]>;
 export declare function loadAgentSkillFromAFS({ afs, }: {
     afs: AFS;
 }): Promise<AgentSkill | undefined>;

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

@@ -23,7 +23,7 @@ export async function loadSkills(paths) {
     }
     return skills;
 }
-export async function loadAgentSkillFromAFS({ afs, }) {
+export async function discoverSkillsFromAFS(afs) {
     const modules = await afs.listModules();
     const filtered = modules.filter(({ module: m }) => "options" in m &&
         typeof m.options === "object" &&
@@ -31,7 +31,7 @@ export async function loadAgentSkillFromAFS({ afs, }) {
         "agentSkills" in m.options &&
         m.options.agentSkills === true);
     if (!filtered.length)
-        return;
+        return [];
     const skills = [];
     for (const module of filtered) {
         const data = (await afs
@@ -48,6 +48,10 @@ export async function loadAgentSkillFromAFS({ afs, }) {
             skills.push(skill);
         }
     }
+    return skills;
+}
+export async function loadAgentSkillFromAFS({ afs, }) {
+    const skills = await discoverSkillsFromAFS(afs);
     if (!skills.length)
         return;
     return new AgentSkill({

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.72.0-beta.16",
+  "version": "1.72.0-beta.18",
   "description": "The functional core of agentic AI",
   "publishConfig": {
     "access": "public"
@@ -94,9 +94,9 @@
     "zod-from-json-schema": "^0.0.5",
     "zod-to-json-schema": "^3.24.6",
     "@aigne/afs": "^1.4.0-beta.8",
+    "@aigne/observability-api": "^0.11.14-beta.3",
     "@aigne/afs-history": "^1.2.0-beta.9",
-    "@aigne/platform-helpers": "^0.6.7-beta.1",
-    "@aigne/observability-api": "^0.11.14-beta.2"
+    "@aigne/platform-helpers": "^0.6.7-beta.1"
   },
   "devDependencies": {
     "@types/bun": "^1.2.22",