@aigne/core 1.72.0-beta.8 → 1.72.0

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

@@ -41,7 +41,11 @@ 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.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);
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AISessionMemoryExtractor = void 0;
+const zod_1 = require("zod");
+const ai_agent_js_1 = require("../../agents/ai-agent.js");
+const type_utils_js_1 = require("../../utils/type-utils.js");
+const EXTRACTOR_INSTRUCTIONS = `\
+You are a session memory fact extractor. Your task is to extract facts that help continue THIS SESSION's work.
+
+**Key Principle**: Extract WORK CONTEXT (tasks, decisions, blockers), NOT PROJECT DOCUMENTATION (tech stack, code structure, implementation details).
+
+Session memory is for remembering:
+- What we're trying to accomplish
+- Why we made certain choices
+- What problems we encountered
+- Important context for continuing the work
+
+Session memory is NOT for documenting:
+- What the code does (visible in code)
+- How the project is structured (can explore directly)
+- What technologies are used (obvious from files)
+
+## User Memory Facts (Long-term, cross-session)
+
+${"```"}yaml alt="user-memory-facts"
+{{ existingUserFacts | yaml.stringify }}
+${"```"}
+
+## Existing Session Memory Facts
+
+${"```"}yaml alt="existing-facts"
+{{ existingFacts | yaml.stringify }}
+${"```"}
+
+## Recent Conversation
+
+${"```"}yaml alt="recent-messages"
+{{ messages | yaml.stringify }}
+${"```"}
+
+## Guidelines
+
+1. **Avoid duplicating User Memory (CRITICAL)**:
+   - User Memory contains long-term, cross-session facts about the user
+   - DO NOT extract facts that are already covered in User Memory
+   - Focus on session-specific information that User Memory doesn't capture
+   - Example: If User Memory has "User prefers TypeScript", don't add "User is using TypeScript" to session memory
+
+2. **Output only changes (CRITICAL)**:
+   - Only output facts that need to be added or updated
+   - DO NOT output facts that already exist and don't need changes
+   - Each label in newFacts must be unique
+   - When a label already exists in session memory:
+     - Include it in newFacts ONLY if conversation provides new information to update it
+     - Omit it from newFacts if it doesn't need changes
+
+3. **What to extract** (Session context, NOT project documentation):
+   - **Current tasks and goals**: What the user is trying to accomplish in this session
+   - **Important decisions**: Key choices made and WHY (not just WHAT was chosen)
+   - **Session-specific constraints**: Temporary requirements or limitations for this work
+   - **Blockers and context**: Issues encountered and relevant background
+   - **Session-specific user preferences**: Only if different from User Memory for this session
+
+4. **What NOT to extract** (Can be inferred from code or documentation):
+   - ❌ Tech stack details (e.g., "Project uses React") - obvious from package.json
+   - ❌ Code structure facts (e.g., "Code is in /src") - can be seen directly
+   - ❌ Implementation details (e.g., "Function X does Y") - visible in code
+   - ❌ Architecture documentation - should be in actual docs, not memory
+   - ❌ Generic project facts that don't help with current work
+
+5. **When to output a fact in newFacts**:
+   - **New fact**: Learning something new about current work context not in existing session memory
+   - **Updated fact**: New information about current tasks or decisions
+   - **DO NOT output**: Facts already in session memory, facts covered by User Memory, or obvious code facts
+   - Example: Extract "User is fixing the memory duplication bug to optimize token usage" ✓
+   - Example: Don't extract "Project uses TypeScript" ❌ (obvious from code)
+
+6. **Remove outdated facts** by including their labels in removeFacts:
+   - Facts that are no longer relevant to current session
+   - Facts that have been superseded by new information
+
+7. **Label naming conventions**:
+   - Use short, descriptive, kebab-case labels
+   - Focus on: "task-*" (current tasks), "decision-*" (key decisions), "ctx-*" (context), "blocker-*" (blockers)
+   - Examples: "task-fix-memory-bug", "decision-use-incremental-updates", "ctx-working-on-compact-module", "blocker-type-error"
+
+8. **Fact content guidelines**:
+   - Write concise, actionable facts (1-2 sentences max)
+   - Focus on WHY and WHAT (goals, decisions, context), not HOW (implementation details)
+   - Information should help continue the work, not document the codebase
+
+9. **Extraction criteria**:
+   - Only extract if there's clear, explicit information in the conversation
+   - The information should be useful for continuing the current work
+   - Don't make assumptions or infer beyond what's stated
+   - When in doubt about whether something changed, don't output it
+
+Output only the new or updated facts in newFacts, and any labels to remove in removeFacts.`;
+class AISessionMemoryExtractor extends ai_agent_js_1.AIAgent {
+    constructor(options) {
+        super({
+            name: "SessionMemoryExtractor",
+            description: "Extracts and maintains session memory facts from conversations",
+            inputSchema: zod_1.z.object({
+                existingUserFacts: (0, zod_1.optional)(zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string(),
+                    fact: zod_1.z.string(),
+                    confidence: (0, zod_1.optional)(zod_1.z.number()),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string())),
+                }))
+                    .describe("User memory facts (long-term, cross-session) to avoid duplication")),
+                existingFacts: (0, zod_1.optional)(zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string(),
+                    fact: zod_1.z.string(),
+                    confidence: (0, zod_1.optional)(zod_1.z.number()),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string())),
+                }))
+                    .describe("Existing session memory facts for context and deduplication")),
+                messages: zod_1.z.array(zod_1.z.any()).describe("Recent conversation messages"),
+            }),
+            outputSchema: zod_1.z.object({
+                newFacts: zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string().describe("Short, semantic label for the fact"),
+                    fact: zod_1.z.string().describe("The fact content"),
+                    confidence: (0, zod_1.optional)(zod_1.z.number().min(0).max(1).describe("Confidence score (0-1)")),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string()).describe("Classification tags")),
+                }))
+                    .describe("Facts to add or update in session memory. Only include facts that are new or need updates. Do not include unchanged facts."),
+                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",
+            },
+        });
+    }
+}
+exports.AISessionMemoryExtractor = AISessionMemoryExtractor;

package/lib/cjs/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/cjs/prompt/compact/types.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_COMPACT_ASYNC = exports.DEFAULT_KEEP_RECENT_RATIO = exports.DEFAULT_MAX_TOKENS = exports.DEFAULT_COMPACT_MODE = void 0;
+exports.DEFAULT_USER_MEMORY_ASYNC = exports.DEFAULT_USER_MEMORY_MODE = exports.DEFAULT_SESSION_MEMORY_ASYNC = exports.DEFAULT_SESSION_MEMORY_MODE = exports.DEFAULT_MEMORY_QUERY_LIMIT = exports.DEFAULT_MEMORY_RATIO = exports.DEFAULT_COMPACT_ASYNC = exports.DEFAULT_KEEP_RECENT_RATIO = exports.DEFAULT_MAX_TOKENS = exports.DEFAULT_COMPACT_MODE = exports.DEFAULT_SESSION_MODE = void 0;
+/**
+ * Default session mode
+ */
+exports.DEFAULT_SESSION_MODE = "auto";
 /**
  * Default compaction mode
  */
@@ -17,3 +21,33 @@ exports.DEFAULT_KEEP_RECENT_RATIO = 0.5;
  * Default async mode for compaction
  */
 exports.DEFAULT_COMPACT_ASYNC = true;
+// ============================================================================
+// User Memory Types
+// ============================================================================
+/**
+ * Default ratio of maxTokens to allocate for user memory
+ */
+exports.DEFAULT_MEMORY_RATIO = 0.04;
+/**
+ * Default query limit for loading memory facts
+ */
+exports.DEFAULT_MEMORY_QUERY_LIMIT = 200;
+/**
+ * Default session memory mode
+ */
+exports.DEFAULT_SESSION_MEMORY_MODE = "auto";
+/**
+ * Default async mode for session memory extraction
+ */
+exports.DEFAULT_SESSION_MEMORY_ASYNC = true;
+// ============================================================================
+// User Memory Types
+// ============================================================================
+/**
+ * Default user memory mode
+ */
+exports.DEFAULT_USER_MEMORY_MODE = "auto";
+/**
+ * Default async mode for user memory consolidation
+ */
+exports.DEFAULT_USER_MEMORY_ASYNC = true;

package/lib/cjs/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/cjs/prompt/compact/user-memory-extractor.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIUserMemoryExtractor = void 0;
+const zod_1 = require("zod");
+const ai_agent_js_1 = require("../../agents/ai-agent.js");
+const type_utils_js_1 = require("../../utils/type-utils.js");
+const EXTRACTOR_INSTRUCTIONS = `\
+You are a user memory extractor. Your task is to extract long-term user memory facts from session memory that represent verified, persistent user characteristics.
+
+## Session Memory Facts (from current session)
+
+${"```"}yaml alt="session-facts"
+{{ sessionFacts | yaml.stringify }}
+${"```"}
+
+## Existing User Memory Facts
+
+${"```"}yaml alt="existing-user-facts"
+{{ existingUserFacts | yaml.stringify }}
+${"```"}
+
+## Guidelines
+
+1. **Extract session facts into long-term user memory**:
+   - Promote facts that represent lasting user characteristics (preferences, skills, working style)
+   - Filter out temporary or session-specific information
+   - Aggregate patterns observed across multiple sessions
+   - Verify consistency with existing user memory
+
+2. **User memory should focus on USER characteristics**:
+   - **Preferences**: Lasting tool/framework/language preferences the user likes to use
+   - **Skills**: Confirmed technical expertise and proficiency levels of the user
+   - **Working style**: User's communication preferences, workflow patterns, coding standards
+   - **Personal context**: Stable personal context (timezone, team structure, role, work hours)
+   - **Project basic info**: What projects the user is working on and their role in them
+     - Example: "User is building an AI Agent framework called aigne-framework"
+     - Example: "User is the tech lead on a React e-commerce project"
+     - DO NOT include project technical details, architecture, or implementation specifics
+
+3. **DO NOT include in user memory**:
+   - Session-specific tasks or temporary goals
+   - Bugs or issues being debugged in a specific session
+   - One-time decisions or experimental choices
+   - Unverified assumptions or single-instance observations
+   - **Project technical details**: architecture decisions, tech stack specifics, implementation details
+   - **Project problems**: current bugs, issues, technical debt, or temporary blockers
+   - Information about the codebase structure or specific files/modules
+
+4. **Output only changes (CRITICAL)**:
+   - Only output facts that need to be added or updated
+   - DO NOT output facts that already exist and don't need changes
+   - Each label in newFacts must be unique
+   - When a label already exists in user memory:
+     - Include it in newFacts ONLY if session provides new information to update it
+     - Omit it from newFacts if it doesn't need changes
+   - Use the same label format as session memory: "pref-*", "skill-*", "proj-*", "ctx-*"
+
+5. **When to output a fact in newFacts**:
+   - **New fact**: Extracting a brand new user characteristic not in existing user memory
+   - **Updated fact**: Session provides new information that enhances an existing fact
+   - **Refined fact**: Multiple sessions show patterns that refine existing facts
+   - DO NOT output if: The fact already exists and session doesn't add new information
+
+6. **When to remove facts** (add labels to removeFacts):
+   - Facts are proven to be outdated or incorrect
+   - User explicitly changed their approach permanently
+   - Facts are redundant with newer, better facts
+
+7. **Confidence scoring**:
+   - Higher confidence (0.8-1.0): Verified across multiple sessions or explicitly stated
+   - Medium confidence (0.5-0.7): Observed patterns but limited data
+   - Lower confidence (0.3-0.4): Tentative patterns, may need more verification
+   - Below 0.3: Don't extract into user memory yet
+
+8. **Extraction criteria**:
+   - Only extract facts that are clearly valuable long-term
+   - Prefer quality over quantity - fewer high-confidence facts are better
+   - When in doubt, wait for more sessions to verify the pattern
+
+Output the extracted user memory facts and any facts to remove.`;
+class AIUserMemoryExtractor extends ai_agent_js_1.AIAgent {
+    constructor(options) {
+        super({
+            name: "UserMemoryExtractor",
+            description: "Extracts long-term user memory facts from session memory",
+            inputSchema: zod_1.z.object({
+                sessionFacts: zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string(),
+                    fact: zod_1.z.string(),
+                    confidence: (0, zod_1.optional)(zod_1.z.number()),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string())),
+                }))
+                    .describe("Session memory facts to extract from"),
+                existingUserFacts: (0, zod_1.optional)(zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string(),
+                    fact: zod_1.z.string(),
+                    confidence: (0, zod_1.optional)(zod_1.z.number()),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string())),
+                }))
+                    .describe("Existing user memory facts for context and deduplication")),
+            }),
+            outputSchema: zod_1.z.object({
+                newFacts: zod_1.z
+                    .array(zod_1.z.object({
+                    label: zod_1.z.string().describe("Short, semantic label for the fact (must be unique)"),
+                    fact: zod_1.z.string().describe("The extracted fact content"),
+                    confidence: (0, zod_1.optional)(zod_1.z.number().min(0).max(1).describe("Confidence score (0-1)")),
+                    tags: (0, zod_1.optional)(zod_1.z.array(zod_1.z.string()).describe("Classification tags")),
+                }))
+                    .describe("Facts to add or update in user memory. Only include facts that are new or need updates. Do not include unchanged facts."),
+                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",
+            },
+        });
+    }
+}
+exports.AIUserMemoryExtractor = AIUserMemoryExtractor;

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 }];
                     }
                 }
@@ -82,7 +82,7 @@ class PromptBuilder {
             userId,
             sessionId,
             afs,
-            compact: options.agent?.compact,
+            ...options.agent?.session,
         });
         const { systemMessage, userMessage } = await this.buildMessages(options);
         if (systemMessage)

package/lib/cjs/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/cjs/prompt/skills/afs/agent-skill/agent-skill.js

@@ -8,6 +8,12 @@ const skillToolInputSchema = zod_1.z.object({
     args: zod_1.z.string().optional().describe("The arguments to pass to the skill."),
 });
 class AgentSkill extends agent_js_1.Agent {
+    formatOutput(output) {
+        if ("result" in output && typeof output.result === "string") {
+            return output.result;
+        }
+        return super.formatOutput(output);
+    }
     constructor(options) {
         super({
             name: "Skill",

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