@aigne/core 1.72.0-beta.9 → 1.72.0

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

@@ -1,5 +1,13 @@
 import type { Agent, Message } from "../../agents/agent.js";
 import type { ChatModelInputMessage } from "../../agents/chat-model.js";
+/**
+ * Session mode type
+ */
+export type SessionMode = "auto" | "disabled";
+/**
+ * Default session mode
+ */
+export declare const DEFAULT_SESSION_MODE: SessionMode;
 /**
  * Default compaction mode
  */
@@ -29,6 +37,13 @@ export interface EntryContent {
  */
 export interface CompactContent extends Message {
     summary: string;
+    /**
+     * Last Agent Skill content in the session
+     * Preserved across compactions to maintain skill instructions
+     */
+    lastAgentSkill?: {
+        content: string;
+    };
 }
 /**
  * Input structure for the compactor agent
@@ -77,3 +92,245 @@ export interface CompactConfig {
      */
     compactor?: Compactor;
 }
+/**
+ * Default ratio of maxTokens to allocate for user memory
+ */
+export declare const DEFAULT_MEMORY_RATIO = 0.04;
+/**
+ * Default query limit for loading memory facts
+ */
+export declare const DEFAULT_MEMORY_QUERY_LIMIT = 200;
+/**
+ * Content structure for a single memory fact
+ *
+ * Used by both session memory and user memory to store learned facts.
+ * Each fact is stored as an individual AFSEntry with metadata at the AFSEntry level.
+ *
+ * Storage paths:
+ * - Session Memory:
+ *   - List: /by-session/:sessionId/@metadata/memory
+ *   - Create: /by-session/:sessionId/@metadata/memory/new
+ *   - Read: /by-session/:sessionId/@metadata/memory/:memoryId
+ * - User Memory:
+ *   - List: /by-user/:userId/@metadata/memory
+ *   - Create: /by-user/:userId/@metadata/memory/new
+ *   - Read: /by-user/:userId/@metadata/memory/:memoryId
+ *
+ * @example
+ * AFSEntry<MemoryFact> {
+ *   id: "fact-001",           // AFSEntry ID (auto-generated)
+ *   userId: "user-001",
+ *   agentId: "assistant",      // which agent learned this fact
+ *   sessionId: "session-123",  // which session it was learned from (if applicable)
+ *   createdAt: Date,
+ *   content: {
+ *     label: "pref-package-manager",  // semantic label for this fact
+ *     fact: "User prefers using pnpm",
+ *     confidence: 0.9,
+ *     tags: ["preference", "tooling"]
+ *   }
+ * }
+ */
+export interface MemoryFact {
+    /**
+     * Semantic label for this fact (short, human-readable)
+     * Used for updates and deletions to uniquely identify facts
+     * @example "pref-package-manager", "skill-typescript", "proj-main-language"
+     */
+    label: string;
+    /**
+     * The fact content (text description)
+     */
+    fact: string;
+    /**
+     * Confidence score (0-1)
+     * Higher values indicate more certain facts
+     * @default 1.0
+     */
+    confidence?: number;
+    /**
+     * Classification tags for the fact
+     * @example ['preference', 'technical', 'project-specific']
+     */
+    tags?: string[];
+}
+/**
+ * Input structure for the memory extractor agent
+ */
+export interface MemoryExtractorInput extends Message {
+    /**
+     * User memory facts (long-term, cross-session) to avoid duplication
+     */
+    existingUserFacts?: MemoryFact[];
+    /**
+     * Existing session memory facts (for context and deduplication)
+     */
+    existingFacts?: MemoryFact[];
+    /**
+     * Recent conversation messages to extract facts from
+     */
+    messages: ChatModelInputMessage[];
+}
+/**
+ * Output structure from the memory extractor agent
+ */
+export interface MemoryExtractorOutput extends Message {
+    /**
+     * New or updated facts from the conversation
+     * Only include facts that need to be added or updated
+     * Do not include unchanged facts that already exist
+     */
+    newFacts: MemoryFact[];
+    /**
+     * Fact labels to remove from existing memory
+     * Each string should match a label in existingFacts
+     * @example ["pref-package-manager", "skill-old-framework"]
+     */
+    removeFacts?: string[];
+}
+/**
+ * Type alias for a memory extractor agent
+ */
+export type MemoryExtractor = Agent<MemoryExtractorInput, MemoryExtractorOutput>;
+/**
+ * Default session memory mode
+ */
+export declare const DEFAULT_SESSION_MEMORY_MODE: "auto";
+/**
+ * Default async mode for session memory extraction
+ */
+export declare const DEFAULT_SESSION_MEMORY_ASYNC = true;
+/**
+ * Metadata for tracking session memory extraction progress
+ *
+ * This metadata is stored in each memory entry's metadata field.
+ * When extracting new facts, the latestEntryId is recorded in the metadata
+ * to track which history entries have been processed.
+ */
+export interface SessionMemoryMetadata {
+    /**
+     * ID of the last extracted history entry
+     * Used to determine which entries still need processing
+     */
+    latestEntryId?: string;
+}
+/**
+ * Default user memory mode
+ */
+export declare const DEFAULT_USER_MEMORY_MODE: "auto";
+/**
+ * Default async mode for user memory consolidation
+ */
+export declare const DEFAULT_USER_MEMORY_ASYNC = true;
+/**
+ * Input structure for the user memory extractor agent
+ */
+export interface UserMemoryExtractorInput extends Message {
+    /**
+     * Session memory facts from multiple sessions to consolidate
+     */
+    sessionFacts: MemoryFact[];
+    /**
+     * Existing user memory facts (for context and deduplication)
+     */
+    existingUserFacts?: MemoryFact[];
+}
+/**
+ * Output structure from the user memory extractor agent
+ */
+export interface UserMemoryExtractorOutput extends Message {
+    /**
+     * New or updated facts for user memory
+     * Only include facts that need to be added or updated
+     * Do not include unchanged facts that already exist
+     * Each label should be unique - these will replace old facts with same labels
+     */
+    newFacts: MemoryFact[];
+    /**
+     * Fact labels to remove from user memory
+     * Each string should match a label in existingUserFacts
+     */
+    removeFacts?: string[];
+}
+/**
+ * Type alias for a user memory extractor agent
+ */
+export type UserMemoryExtractor = Agent<UserMemoryExtractorInput, UserMemoryExtractorOutput>;
+/**
+ * Configuration for user memory
+ * User memory contains long-term facts consolidated from multiple sessions
+ */
+export interface UserMemoryConfig {
+    /**
+     * User memory mode
+     * - "auto": Enable memory and auto-consolidate at appropriate times
+     * - "disabled": Disable user memory completely
+     * @default DEFAULT_USER_MEMORY_MODE ("auto")
+     */
+    mode?: "auto" | "disabled";
+    /**
+     * Ratio of maxTokens to allocate for user memory (0-1)
+     *
+     * Defines what portion of maxTokens budget should be allocated for
+     * injecting user memory facts into the prompt.
+     *
+     * @default DEFAULT_MEMORY_RATIO (0.04 = 4% of maxTokens)
+     * @example 0.04 means if maxTokens=80000, allocate 3200 tokens for memory
+     */
+    memoryRatio?: number;
+    /**
+     * Maximum number of fact entries to load from storage
+     * @default DEFAULT_MEMORY_QUERY_LIMIT (200)
+     */
+    queryLimit?: number;
+    /**
+     * Whether to perform memory consolidation asynchronously
+     * @default DEFAULT_USER_MEMORY_ASYNC (true)
+     */
+    async?: boolean;
+    /**
+     * Agent that extracts user memory facts from session memory
+     * Input: { sessionFacts: MemoryFact[], existingUserFacts?: MemoryFact[] }
+     * Output: { newFacts: MemoryFact[], removeFacts?: string[] }
+     */
+    extractor?: UserMemoryExtractor;
+}
+/**
+ * Configuration for session memory
+ * Session memory contains facts extracted from the current session's conversation
+ */
+export interface SessionMemoryConfig {
+    /**
+     * Session memory mode
+     * - "auto": Enable memory and auto-update after each conversation turn
+     * - "disabled": Disable memory completely
+     * @default DEFAULT_SESSION_MEMORY_MODE ("auto")
+     */
+    mode?: "auto" | "disabled";
+    /**
+     * Ratio of maxTokens to allocate for session memory (0-1)
+     *
+     * Defines what portion of maxTokens budget should be allocated for
+     * injecting session memory facts into the prompt.
+     *
+     * @default DEFAULT_MEMORY_RATIO (0.04 = 4% of maxTokens)
+     * @example 0.04 means if maxTokens=80000, allocate 3200 tokens for memory
+     */
+    memoryRatio?: number;
+    /**
+     * Maximum number of fact entries to load from storage
+     * @default DEFAULT_MEMORY_QUERY_LIMIT (200)
+     */
+    queryLimit?: number;
+    /**
+     * Whether to perform memory extraction asynchronously
+     * @default DEFAULT_SESSION_MEMORY_ASYNC (true)
+     */
+    async?: boolean;
+    /**
+     * Agent that extracts facts from conversation messages
+     * Input: { existingUserFacts?: MemoryFact[], existingFacts?: MemoryFact[], messages: ChatModelInputMessage[] }
+     * Output: { newFacts: MemoryFact[], removeFacts?: string[] }
+     */
+    extractor?: MemoryExtractor;
+}

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

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

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

@@ -1,4 +1,5 @@
 import { Agent, type AgentOptions, type Message } from "../../../../agents/agent.js";
+import type { PromiseOrValue } from "../../../../utils/type-utils.js";
 import type { Skill } from "./skill-loader.js";
 export interface SkillToolInput extends Message {
     skill: string;
@@ -11,6 +12,7 @@ export interface SkillToolOptions extends AgentOptions<SkillToolInput, SkillTool
     agentSkills: Skill[];
 }
 export declare class AgentSkill extends Agent<SkillToolInput, SkillToolOutput> {
+    formatOutput(output: SkillToolOutput | Message): PromiseOrValue<string>;
     constructor(options: SkillToolOptions);
     private agentSkills;
     process(input: SkillToolInput): Promise<SkillToolOutput>;

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

@@ -6,8 +6,7 @@ export interface Skill {
     description: string;
     content: string;
 }
-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/dts/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/dts/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/esm/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/esm/agents/agent.js

@@ -3,6 +3,7 @@ import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import equal from "fast-deep-equal";
 import nunjucks from "nunjucks";
 import { joinURL } from "ufo";
+import { stringify } from "yaml";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { codeToFunctionAgentFn } from "../loader/function-agent.js";
@@ -506,6 +507,7 @@ export class Agent {
             ...options,
             model: this.model || options.model,
             imageModel: this.imageModel || options.imageModel,
+            caller: this,
         });
     });
     /**
@@ -667,6 +669,9 @@ export class Agent {
             });
         }
     }
+    formatOutput(output) {
+        return stringify(output);
+    }
     /**
      * Shut down the agent and clean up resources
      *

package/lib/esm/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/esm/agents/ai-agent.js

@@ -3,6 +3,7 @@ import { getNestAgentSchema } from "../loader/agent-yaml.js";
 import { camelizeSchema, getInstructionsSchema, instructionsToPromptBuilder, optionalize, } from "../loader/schema.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { STRUCTURED_STREAM_INSTRUCTIONS } from "../prompt/prompts/structured-stream-instructions.js";
+import { AgentSkill } from "../prompt/skills/afs/agent-skill/agent-skill.js";
 import * as fastq from "../utils/queue.js";
 import { mergeAgentResponseChunk } from "../utils/stream-utils.js";
 import { ExtractMetadataTransform } from "../utils/structured-stream-extractor.js";
@@ -89,7 +90,7 @@ export class AIAgent extends Agent {
     static schema({ filepath }) {
         const instructionsSchema = getInstructionsSchema({ filepath });
         const nestAgentSchema = getNestAgentSchema({ filepath });
-        return camelizeSchema(z.object({
+        const schema = camelizeSchema(z.object({
             instructions: optionalize(instructionsSchema),
             inputKey: optionalize(z.string()),
             outputKey: optionalize(z.string()),
@@ -100,28 +101,75 @@ export class AIAgent extends Agent {
             keepTextInToolUses: optionalize(z.boolean()),
             catchToolsError: optionalize(z.boolean()),
             structuredStreamMode: optionalize(z.boolean()),
-            compact: camelizeSchema(optionalize(z.object({
+            session: optionalize(camelizeSchema(z.object({
                 mode: optionalize(z.enum(["auto", "disabled"])),
-                maxTokens: z.number().int().min(0).optional(),
-                keepRecentRatio: optionalize(z.number().min(0).max(1)),
-                async: optionalize(z.boolean()),
-                compactor: optionalize(nestAgentSchema),
+                sessionMemory: optionalize(camelizeSchema(z.object({
+                    mode: optionalize(z.enum(["auto", "disabled"])),
+                    memoryRatio: optionalize(z.number().min(0).max(1)),
+                    queryLimit: optionalize(z.number().int().min(0)),
+                    async: optionalize(z.boolean()),
+                    extractor: optionalize(nestAgentSchema),
+                }))),
+                userMemory: optionalize(camelizeSchema(z.object({
+                    mode: optionalize(z.enum(["auto", "disabled"])),
+                    memoryRatio: optionalize(z.number().min(0).max(1)),
+                    queryLimit: optionalize(z.number().int().min(0)),
+                    async: optionalize(z.boolean()),
+                    extractor: optionalize(nestAgentSchema),
+                }))),
+                compact: optionalize(camelizeSchema(z.object({
+                    mode: optionalize(z.enum(["auto", "disabled"])),
+                    maxTokens: z.number().int().min(0).optional(),
+                    keepRecentRatio: optionalize(z.number().min(0).max(1)),
+                    async: optionalize(z.boolean()),
+                    compactor: 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 && instructionsToPromptBuilder(valid.instructions),
-            compact: {
-                ...valid.compact,
-                compactor: valid.compact?.compactor
-                    ? await options.options?.loadNestAgent(options.filepath, valid.compact.compactor, options.options)
-                    : undefined,
-            },
+            session: sessionConfig,
         });
     }
     /**
@@ -162,7 +210,7 @@ export class AIAgent extends 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;
@@ -278,7 +326,10 @@ export class AIAgent extends 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) {
@@ -364,16 +415,27 @@ export class AIAgent extends 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 }) => {
@@ -390,40 +452,38 @@ export class AIAgent extends 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 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) => isTransferAgentOutput(i.output))?.output;
                     if (transferOutput)
                         return transferOutput;
+                    await session.appendCurrentMessages([toolCallMessage, ...toolResultMessages], options);
                     continue;
                 }
             }
@@ -440,7 +500,7 @@ export class AIAgent extends Agent {
             if (!isEmpty(result)) {
                 yield { delta: { json: result } };
             }
-            await session.endMessage(result, options);
+            await session.endMessage(result, undefined, options);
             return;
         }
     }